skein (empty) → 0.1
raw patch · 20 files changed
+14885/−0 lines, 20 filesdep +basedep +bytestringdep +cerealsetup-changed
Dependencies added: base, bytestring, cereal, crypto-api, filepath, hspec, skein, tagged, transformers
Files
- LICENSE +30/−0
- Setup.hs +2/−0
- c_impl/optimized/skein.c +753/−0
- c_impl/optimized/skein.h +315/−0
- c_impl/optimized/skein_block.c +689/−0
- c_impl/optimized/skein_debug.c +230/−0
- c_impl/optimized/skein_debug.h +48/−0
- c_impl/optimized/skein_iv.h +199/−0
- c_impl/optimized/skein_port.h +113/−0
- c_impl/reference/skein.c +747/−0
- c_impl/reference/skein.h +315/−0
- c_impl/reference/skein_block.c +369/−0
- c_impl/reference/skein_debug.c +230/−0
- c_impl/reference/skein_debug.h +48/−0
- c_impl/reference/skein_port.h +45/−0
- skein.cabal +122/−0
- src/Crypto/Skein.hs +760/−0
- src/Crypto/Skein/Internal.hsc +154/−0
- tests/runtests.hs +174/−0
- tests/skein_golden_kat.txt +9542/−0
+ LICENSE view
@@ -0,0 +1,30 @@+Copyright (c)2011, Felipe Lessa++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++ * Redistributions of source code must retain the above copyright+ notice, this list of conditions and the following disclaimer.++ * Redistributions in binary form must reproduce the above+ copyright notice, this list of conditions and the following+ disclaimer in the documentation and/or other materials provided+ with the distribution.++ * Neither the name of Felipe Lessa nor the names of other+ contributors may be used to endorse or promote products derived+ from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ c_impl/optimized/skein.c view
@@ -0,0 +1,753 @@+/*********************************************************************** +** +** Implementation of the Skein hash function. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ + +#define SKEIN_PORT_CODE /* instantiate any code in skein_port.h */ + +#include <string.h> /* get the memcpy/memset functions */ +#include "skein.h" /* get the Skein API definitions */ +#include "skein_iv.h" /* get precomputed IVs */ + +/*****************************************************************/ +/* External function to process blkCnt (nonzero) full block(s) of data. */ +void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); +void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); +void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); + +/*****************************************************************/ +/* 256-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN_256_STATE_BYTES]; + u64b_t w[SKEIN_256_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + + switch (hashBitLen) + { /* use pre-computed values, where available */ +#ifndef SKEIN_NO_PRECOMP + case 256: memcpy(ctx->X,SKEIN_256_IV_256,sizeof(ctx->X)); break; + case 224: memcpy(ctx->X,SKEIN_256_IV_224,sizeof(ctx->X)); break; + case 160: memcpy(ctx->X,SKEIN_256_IV_160,sizeof(ctx->X)); break; + case 128: memcpy(ctx->X,SKEIN_256_IV_128,sizeof(ctx->X)); break; +#endif + default: + /* here if there is no precomputed IV value available */ + /* build/process the config block, type == CONFIG (could be precomputed) */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + break; + } + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + union + { + u08b_t b[SKEIN_256_STATE_BYTES]; + u64b_t w[SKEIN_256_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein_256_Update(ctx,key,keyBytes); /* hash the key */ + Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ +#if SKEIN_NEED_SWAP + { + uint_t i; + for (i=0;i<SKEIN_256_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } +#endif + } + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(256,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash (default) */ + ctx->h.bCnt = 0; /* buffer b[] starts out empty */ + Skein_Start_New_Type(ctx,MSG); + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); + Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN_256_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ + Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); + msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; + msg += n * SKEIN_256_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_256_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); + + Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_256_BLOCK_BYTES) + n = SKEIN_256_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_256_API_CodeSize(void) + { + return ((u08b_t *) Skein_256_API_CodeSize) - + ((u08b_t *) Skein_256_Init); + } +#endif + +/*****************************************************************/ +/* 512-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN_512_STATE_BYTES]; + u64b_t w[SKEIN_512_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + + switch (hashBitLen) + { /* use pre-computed values, where available */ +#ifndef SKEIN_NO_PRECOMP + case 512: memcpy(ctx->X,SKEIN_512_IV_512,sizeof(ctx->X)); break; + case 384: memcpy(ctx->X,SKEIN_512_IV_384,sizeof(ctx->X)); break; + case 256: memcpy(ctx->X,SKEIN_512_IV_256,sizeof(ctx->X)); break; + case 224: memcpy(ctx->X,SKEIN_512_IV_224,sizeof(ctx->X)); break; +#endif + default: + /* here if there is no precomputed IV value available */ + /* build/process the config block, type == CONFIG (could be precomputed) */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + break; + } + + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + union + { + u08b_t b[SKEIN_512_STATE_BYTES]; + u64b_t w[SKEIN_512_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein_512_Update(ctx,key,keyBytes); /* hash the key */ + Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ +#if SKEIN_NEED_SWAP + { + uint_t i; + for (i=0;i<SKEIN_512_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } +#endif + } + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(512,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash (default) */ + ctx->h.bCnt = 0; /* buffer b[] starts out empty */ + Skein_Start_New_Type(ctx,MSG); + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); + Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN_512_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ + Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); + msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; + msg += n * SKEIN_512_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_512_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); + + Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_512_BLOCK_BYTES) + n = SKEIN_512_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_512_API_CodeSize(void) + { + return ((u08b_t *) Skein_512_API_CodeSize) - + ((u08b_t *) Skein_512_Init); + } +#endif + +/*****************************************************************/ +/* 1024-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN1024_STATE_BYTES]; + u64b_t w[SKEIN1024_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + + switch (hashBitLen) + { /* use pre-computed values, where available */ +#ifndef SKEIN_NO_PRECOMP + case 512: memcpy(ctx->X,SKEIN1024_IV_512 ,sizeof(ctx->X)); break; + case 384: memcpy(ctx->X,SKEIN1024_IV_384 ,sizeof(ctx->X)); break; + case 1024: memcpy(ctx->X,SKEIN1024_IV_1024,sizeof(ctx->X)); break; +#endif + default: + /* here if there is no precomputed IV value available */ + /* build/process the config block, type == CONFIG (could be precomputed) */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + break; + } + + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + union + { + u08b_t b[SKEIN1024_STATE_BYTES]; + u64b_t w[SKEIN1024_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein1024_Update(ctx,key,keyBytes); /* hash the key */ + Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ +#if SKEIN_NEED_SWAP + { + uint_t i; + for (i=0;i<SKEIN1024_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } +#endif + } + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(1024,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash (default) */ + ctx->h.bCnt = 0; /* buffer b[] starts out empty */ + Skein_Start_New_Type(ctx,MSG); + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); + Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN1024_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ + Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); + msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; + msg += n * SKEIN1024_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN1024_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); + + Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN1024_BLOCK_BYTES) + n = SKEIN1024_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein1024_API_CodeSize(void) + { + return ((u08b_t *) Skein1024_API_CodeSize) - + ((u08b_t *) Skein1024_Init); + } +#endif + +/**************** Functions to support MAC/tree hashing ***************/ +/* (this code is identical for Optimized and Reference versions) */ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); + Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); + Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); + Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +#if SKEIN_TREE_HASH +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_256_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_256_BLOCK_BYTES) + n = SKEIN_256_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_512_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_512_BLOCK_BYTES) + n = SKEIN_512_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN1024_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN1024_BLOCK_BYTES) + n = SKEIN1024_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } +#endif
+ c_impl/optimized/skein.h view
@@ -0,0 +1,315 @@+#ifndef _SKEIN_H_ +#define _SKEIN_H_ 1 +/************************************************************************** +** +** Interface declarations and internal definitions for Skein hashing. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +*************************************************************************** +** +** The following compile-time switches may be defined to control some +** tradeoffs between speed, code size, error checking, and security. +** +** The "default" note explains what happens when the switch is not defined. +** +** SKEIN_DEBUG -- make callouts from inside Skein code +** to examine/display intermediate values. +** [default: no callouts (no overhead)] +** +** SKEIN_ERR_CHECK -- how error checking is handled inside Skein +** code. If not defined, most error checking +** is disabled (for performance). Otherwise, +** the switch value is interpreted as: +** 0: use assert() to flag errors +** 1: return SKEIN_FAIL to flag errors +** +***************************************************************************/ + +#include <stddef.h> /* get size_t definition */ +#include "skein_port.h" /* get platform-specific definitions */ + +enum + { + SKEIN_SUCCESS = 0, /* return codes from Skein calls */ + SKEIN_FAIL = 1, + SKEIN_BAD_HASHLEN = 2 + }; + +#define SKEIN_MODIFIER_WORDS ( 2) /* number of modifier (tweak) words */ + +#define SKEIN_256_STATE_WORDS ( 4) +#define SKEIN_512_STATE_WORDS ( 8) +#define SKEIN1024_STATE_WORDS (16) +#define SKEIN_MAX_STATE_WORDS (16) + +#define SKEIN_256_STATE_BYTES ( 8*SKEIN_256_STATE_WORDS) +#define SKEIN_512_STATE_BYTES ( 8*SKEIN_512_STATE_WORDS) +#define SKEIN1024_STATE_BYTES ( 8*SKEIN1024_STATE_WORDS) + +#define SKEIN_256_STATE_BITS (64*SKEIN_256_STATE_WORDS) +#define SKEIN_512_STATE_BITS (64*SKEIN_512_STATE_WORDS) +#define SKEIN1024_STATE_BITS (64*SKEIN1024_STATE_WORDS) + +#define SKEIN_256_BLOCK_BYTES ( 8*SKEIN_256_STATE_WORDS) +#define SKEIN_512_BLOCK_BYTES ( 8*SKEIN_512_STATE_WORDS) +#define SKEIN1024_BLOCK_BYTES ( 8*SKEIN1024_STATE_WORDS) + +typedef struct + { + size_t hashBitLen; /* size of hash result, in bits */ + size_t bCnt; /* current byte count in buffer b[] */ + u64b_t T[SKEIN_MODIFIER_WORDS]; /* tweak words: T[0]=byte cnt, T[1]=flags */ + } Skein_Ctxt_Hdr_t; + +typedef struct /* 256-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN_256_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN_256_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein_256_Ctxt_t; + +typedef struct /* 512-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN_512_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN_512_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein_512_Ctxt_t; + +typedef struct /* 1024-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN1024_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN1024_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein1024_Ctxt_t; + +/* Skein APIs for (incremental) "straight hashing" */ +int Skein_256_Init (Skein_256_Ctxt_t *ctx, size_t hashBitLen); +int Skein_512_Init (Skein_512_Ctxt_t *ctx, size_t hashBitLen); +int Skein1024_Init (Skein1024_Ctxt_t *ctx, size_t hashBitLen); + +int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); +int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); +int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); + +int Skein_256_Final (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Final (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Final (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); + +/* +** Skein APIs for "extended" initialization: MAC keys, tree hashing. +** After an InitExt() call, just use Update/Final calls as with Init(). +** +** 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 +** 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 +** to precompute the MAC IV, then a copy of the context saved and +** reused for each new MAC computation. +**/ +int Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); +int Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); +int Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *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 +*/ +int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t * hashVal); + +#ifndef SKEIN_TREE_HASH +#define SKEIN_TREE_HASH (1) +#endif +#if SKEIN_TREE_HASH +int Skein_256_Output (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Output (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Output (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); +#endif + +/***************************************************************** +** "Internal" Skein definitions +** -- not needed for sequential hashing API, but will be +** helpful for other uses of Skein (e.g., tree hash mode). +** -- included here so that they can be shared between +** reference and optimized code. +******************************************************************/ + +/* tweak word T[1]: bit field starting positions */ +#define SKEIN_T1_BIT(BIT) ((BIT) - 64) /* offset 64 because it's the second word */ + +#define SKEIN_T1_POS_TREE_LVL SKEIN_T1_BIT(112) /* bits 112..118: level in hash tree */ +#define SKEIN_T1_POS_BIT_PAD SKEIN_T1_BIT(119) /* bit 119 : partial final input byte */ +#define SKEIN_T1_POS_BLK_TYPE SKEIN_T1_BIT(120) /* bits 120..125: type field */ +#define SKEIN_T1_POS_FIRST SKEIN_T1_BIT(126) /* bits 126 : first block flag */ +#define SKEIN_T1_POS_FINAL SKEIN_T1_BIT(127) /* bit 127 : final block flag */ + +/* tweak word T[1]: flag bit definition(s) */ +#define SKEIN_T1_FLAG_FIRST (((u64b_t) 1 ) << SKEIN_T1_POS_FIRST) +#define SKEIN_T1_FLAG_FINAL (((u64b_t) 1 ) << SKEIN_T1_POS_FINAL) +#define SKEIN_T1_FLAG_BIT_PAD (((u64b_t) 1 ) << SKEIN_T1_POS_BIT_PAD) + +/* tweak word T[1]: tree level bit field mask */ +#define SKEIN_T1_TREE_LVL_MASK (((u64b_t)0x7F) << SKEIN_T1_POS_TREE_LVL) +#define SKEIN_T1_TREE_LEVEL(n) (((u64b_t) (n)) << SKEIN_T1_POS_TREE_LVL) + +/* tweak word T[1]: block type field */ +#define SKEIN_BLK_TYPE_KEY ( 0) /* key, for MAC and KDF */ +#define SKEIN_BLK_TYPE_CFG ( 4) /* configuration block */ +#define SKEIN_BLK_TYPE_PERS ( 8) /* personalization string */ +#define SKEIN_BLK_TYPE_PK (12) /* public key (for digital signature hashing) */ +#define SKEIN_BLK_TYPE_KDF (16) /* key identifier for KDF */ +#define SKEIN_BLK_TYPE_NONCE (20) /* nonce for PRNG */ +#define SKEIN_BLK_TYPE_MSG (48) /* message processing */ +#define SKEIN_BLK_TYPE_OUT (63) /* output stage */ +#define SKEIN_BLK_TYPE_MASK (63) /* bit field mask */ + +#define SKEIN_T1_BLK_TYPE(T) (((u64b_t) (SKEIN_BLK_TYPE_##T)) << SKEIN_T1_POS_BLK_TYPE) +#define SKEIN_T1_BLK_TYPE_KEY SKEIN_T1_BLK_TYPE(KEY) /* key, for MAC and KDF */ +#define SKEIN_T1_BLK_TYPE_CFG SKEIN_T1_BLK_TYPE(CFG) /* configuration block */ +#define SKEIN_T1_BLK_TYPE_PERS SKEIN_T1_BLK_TYPE(PERS) /* personalization string */ +#define SKEIN_T1_BLK_TYPE_PK SKEIN_T1_BLK_TYPE(PK) /* public key (for digital signature hashing) */ +#define SKEIN_T1_BLK_TYPE_KDF SKEIN_T1_BLK_TYPE(KDF) /* key identifier for KDF */ +#define SKEIN_T1_BLK_TYPE_NONCE SKEIN_T1_BLK_TYPE(NONCE)/* nonce for PRNG */ +#define SKEIN_T1_BLK_TYPE_MSG SKEIN_T1_BLK_TYPE(MSG) /* message processing */ +#define SKEIN_T1_BLK_TYPE_OUT SKEIN_T1_BLK_TYPE(OUT) /* output stage */ +#define SKEIN_T1_BLK_TYPE_MASK SKEIN_T1_BLK_TYPE(MASK) /* field bit mask */ + +#define SKEIN_T1_BLK_TYPE_CFG_FINAL (SKEIN_T1_BLK_TYPE_CFG | SKEIN_T1_FLAG_FINAL) +#define SKEIN_T1_BLK_TYPE_OUT_FINAL (SKEIN_T1_BLK_TYPE_OUT | SKEIN_T1_FLAG_FINAL) + +#define SKEIN_VERSION (1) + +#ifndef SKEIN_ID_STRING_LE /* allow compile-time personalization */ +#define SKEIN_ID_STRING_LE (0x33414853) /* "SHA3" (little-endian)*/ +#endif + +#define SKEIN_MK_64(hi32,lo32) ((lo32) + (((u64b_t) (hi32)) << 32)) +#define SKEIN_SCHEMA_VER SKEIN_MK_64(SKEIN_VERSION,SKEIN_ID_STRING_LE) +#define SKEIN_KS_PARITY SKEIN_MK_64(0x55555555,0x55555555) + +#define SKEIN_CFG_STR_LEN (4*8) + +/* bit field definitions in config block treeInfo word */ +#define SKEIN_CFG_TREE_LEAF_SIZE_POS ( 0) +#define SKEIN_CFG_TREE_NODE_SIZE_POS ( 8) +#define SKEIN_CFG_TREE_MAX_LEVEL_POS (16) + +#define SKEIN_CFG_TREE_LEAF_SIZE_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_LEAF_SIZE_POS) +#define SKEIN_CFG_TREE_NODE_SIZE_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_NODE_SIZE_POS) +#define SKEIN_CFG_TREE_MAX_LEVEL_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_MAX_LEVEL_POS) + +#define SKEIN_CFG_TREE_INFO_SEQUENTIAL (0) /* use as treeInfo in InitExt() call for sequential processing */ +#define SKEIN_CFG_TREE_INFO(leaf,node,maxLevel) ((u64b_t) ((leaf) | ((node) << 8) | ((maxLevel) << 16))) + +/* +** Skein macros for getting/setting tweak words, etc. +** These are useful for partial input bytes, hash tree init/update, etc. +**/ +#define Skein_Get_Tweak(ctxPtr,TWK_NUM) ((ctxPtr)->h.T[TWK_NUM]) +#define Skein_Set_Tweak(ctxPtr,TWK_NUM,tVal) {(ctxPtr)->h.T[TWK_NUM] = (tVal);} + +#define Skein_Get_T0(ctxPtr) Skein_Get_Tweak(ctxPtr,0) +#define Skein_Get_T1(ctxPtr) Skein_Get_Tweak(ctxPtr,1) +#define Skein_Set_T0(ctxPtr,T0) Skein_Set_Tweak(ctxPtr,0,T0) +#define Skein_Set_T1(ctxPtr,T1) Skein_Set_Tweak(ctxPtr,1,T1) + +/* set both tweak words at once */ +#define Skein_Set_T0_T1(ctxPtr,T0,T1) \ + { \ + Skein_Set_T0(ctxPtr,(T0)); \ + Skein_Set_T1(ctxPtr,(T1)); \ + } + +#define Skein_Set_Type(ctxPtr,BLK_TYPE) \ + Skein_Set_T1(ctxPtr,SKEIN_T1_BLK_TYPE_##BLK_TYPE) + +/* set up for starting with a new type: h.T[0]=0; h.T[1] = NEW_TYPE; h.bCnt=0; */ +#define Skein_Start_New_Type(ctxPtr,BLK_TYPE) \ + { Skein_Set_T0_T1(ctxPtr,0,SKEIN_T1_FLAG_FIRST | SKEIN_T1_BLK_TYPE_##BLK_TYPE); (ctxPtr)->h.bCnt=0; } + +#define Skein_Clear_First_Flag(hdr) { (hdr).T[1] &= ~SKEIN_T1_FLAG_FIRST; } +#define Skein_Set_Bit_Pad_Flag(hdr) { (hdr).T[1] |= SKEIN_T1_FLAG_BIT_PAD; } + +#define Skein_Set_Tree_Level(hdr,height) { (hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height);} + +/***************************************************************** +** "Internal" Skein definitions for debugging and error checking +******************************************************************/ +#ifdef SKEIN_DEBUG /* examine/display intermediate values? */ +#include "skein_debug.h" +#else /* default is no callouts */ +#define Skein_Show_Block(bits,ctx,X,blkPtr,wPtr,ksEvenPtr,ksOddPtr) +#define Skein_Show_Round(bits,ctx,r,X) +#define Skein_Show_R_Ptr(bits,ctx,r,X_ptr) +#define Skein_Show_Final(bits,ctx,cnt,outPtr) +#define Skein_Show_Key(bits,ctx,key,keyBytes) +#endif + +#ifndef SKEIN_ERR_CHECK /* run-time checks (e.g., bad params, uninitialized context)? */ +#define Skein_Assert(x,retCode)/* default: ignore all Asserts, for performance */ +#define Skein_assert(x) +#elif defined(SKEIN_ASSERT) +#include <assert.h> +#define Skein_Assert(x,retCode) assert(x) +#define Skein_assert(x) assert(x) +#else +#include <assert.h> +#define Skein_Assert(x,retCode) { if (!(x)) return retCode; } /* caller error */ +#define Skein_assert(x) assert(x) /* internal error */ +#endif + +/***************************************************************** +** Skein block function constants (shared across Ref and Opt code) +******************************************************************/ +enum + { + /* Skein_256 round rotation constants */ + R_256_0_0= 5, R_256_0_1=56, + R_256_1_0=36, R_256_1_1=28, + R_256_2_0=13, R_256_2_1=46, + R_256_3_0=58, R_256_3_1=44, + R_256_4_0=26, R_256_4_1=20, + R_256_5_0=53, R_256_5_1=35, + R_256_6_0=11, R_256_6_1=42, + R_256_7_0=59, R_256_7_1=50, + + /* Skein_512 round rotation constants */ + R_512_0_0=38, R_512_0_1=30, R_512_0_2=50, R_512_0_3=53, + R_512_1_0=48, R_512_1_1=20, R_512_1_2=43, R_512_1_3=31, + R_512_2_0=34, R_512_2_1=14, R_512_2_2=15, R_512_2_3=27, + R_512_3_0=26, R_512_3_1=12, R_512_3_2=58, R_512_3_3= 7, + R_512_4_0=33, R_512_4_1=49, R_512_4_2= 8, R_512_4_3=42, + R_512_5_0=39, R_512_5_1=27, R_512_5_2=41, R_512_5_3=14, + R_512_6_0=29, R_512_6_1=26, R_512_6_2=11, R_512_6_3= 9, + R_512_7_0=33, R_512_7_1=51, R_512_7_2=39, R_512_7_3=35, + + /* Skein1024 round rotation constants */ + R1024_0_0=55, R1024_0_1=43, R1024_0_2=37, R1024_0_3=40, R1024_0_4=16, R1024_0_5=22, R1024_0_6=38, R1024_0_7=12, + R1024_1_0=25, R1024_1_1=25, R1024_1_2=46, R1024_1_3=13, R1024_1_4=14, R1024_1_5=13, R1024_1_6=52, R1024_1_7=57, + R1024_2_0=33, R1024_2_1= 8, R1024_2_2=18, R1024_2_3=57, R1024_2_4=21, R1024_2_5=12, R1024_2_6=32, R1024_2_7=54, + R1024_3_0=34, R1024_3_1=43, R1024_3_2=25, R1024_3_3=60, R1024_3_4=44, R1024_3_5= 9, R1024_3_6=59, R1024_3_7=34, + R1024_4_0=28, R1024_4_1= 7, R1024_4_2=47, R1024_4_3=48, R1024_4_4=51, R1024_4_5= 9, R1024_4_6=35, R1024_4_7=41, + R1024_5_0=17, R1024_5_1= 6, R1024_5_2=18, R1024_5_3=25, R1024_5_4=43, R1024_5_5=42, R1024_5_6=40, R1024_5_7=15, + R1024_6_0=58, R1024_6_1= 7, R1024_6_2=32, R1024_6_3=45, R1024_6_4=19, R1024_6_5=18, R1024_6_6= 2, R1024_6_7=56, + R1024_7_0=47, R1024_7_1=49, R1024_7_2=27, R1024_7_3=58, R1024_7_4=37, R1024_7_5=48, R1024_7_6=53, R1024_7_7=56 + }; + +#ifndef SKEIN_ROUNDS +#define SKEIN_256_ROUNDS_TOTAL (72) /* number of rounds for the different block sizes */ +#define SKEIN_512_ROUNDS_TOTAL (72) +#define SKEIN1024_ROUNDS_TOTAL (80) +#else /* allow command-line define in range 8*(5..14) */ +#define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5)) +#define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/ 10) + 5) % 10) + 5)) +#define SKEIN1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS ) + 5) % 10) + 5)) +#endif + +#endif /* ifndef _SKEIN_H_ */
+ c_impl/optimized/skein_block.c view
@@ -0,0 +1,689 @@+/*********************************************************************** +** +** Implementation of the Skein block functions. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +** Compile-time switches: +** +** SKEIN_USE_ASM -- set bits (256/512/1024) to select which +** versions use ASM code for block processing +** [default: use C for all block sizes] +** +************************************************************************/ + +#include <string.h> +#include "skein.h" + +#ifndef SKEIN_USE_ASM +#define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */ +#endif + +#ifndef SKEIN_LOOP +#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */ +#endif + +#define BLK_BITS (WCNT*64) /* some useful definitions for code here */ +#define KW_TWK_BASE (0) +#define KW_KEY_BASE (3) +#define ks (kw + KW_KEY_BASE) +#define ts (kw + KW_TWK_BASE) + +#ifdef SKEIN_DEBUG +#define DebugSaveTweak(ctx) { ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } +#else +#define DebugSaveTweak(ctx) +#endif + +/***************************** Skein_256 ******************************/ +#if !(SKEIN_USE_ASM & 256) +void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C */ + enum + { + WCNT = SKEIN_256_STATE_WORDS + }; +#undef RCNT +#define RCNT (SKEIN_256_ROUNDS_TOTAL/8) + +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */ +#define SKEIN_UNROLL_256 (((SKEIN_LOOP)/100)%10) +#else +#define SKEIN_UNROLL_256 (0) +#endif + +#if SKEIN_UNROLL_256 +#if (RCNT % SKEIN_UNROLL_256) +#error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */ +#endif + size_t r; + u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ +#else + u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ +#endif + u64b_t X0,X1,X2,X3; /* local copy of context vars, for speed */ + u64b_t w [WCNT]; /* local copy of input block */ +#ifdef SKEIN_DEBUG + const u64b_t *Xptr[4]; /* use for debugging (help compiler put Xn in registers) */ + Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; +#endif + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ts[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[0] = ctx->X[0]; + ks[1] = ctx->X[1]; + ks[2] = ctx->X[2]; + ks[3] = ctx->X[3]; + ks[4] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ SKEIN_KS_PARITY; + + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + DebugSaveTweak(ctx); + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + + X0 = w[0] + ks[0]; /* do the first full key injection */ + X1 = w[1] + ks[1] + ts[0]; + X2 = w[2] + ks[2] + ts[1]; + X3 = w[3] + ks[3]; + + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); /* show starting state values */ + + blkPtr += SKEIN_256_BLOCK_BYTES; + + /* run the rounds */ + +#define Round256(p0,p1,p2,p3,ROT,rNum) \ + 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; \ + +#if SKEIN_UNROLL_256 == 0 +#define R256(p0,p1,p2,p3,ROT,rNum) /* fully unrolled */ \ + Round256(p0,p1,p2,p3,ROT,rNum) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); + +#define I256(R) \ + X0 += ks[((R)+1) % 5]; /* inject the key schedule value */ \ + X1 += ks[((R)+2) % 5] + ts[((R)+1) % 3]; \ + X2 += ks[((R)+3) % 5] + ts[((R)+2) % 3]; \ + X3 += ks[((R)+4) % 5] + (R)+1; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); +#else /* looping version */ +#define R256(p0,p1,p2,p3,ROT,rNum) \ + Round256(p0,p1,p2,p3,ROT,rNum) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); + +#define I256(R) \ + X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ + X1 += ks[r+(R)+1] + ts[r+(R)+0]; \ + X2 += ks[r+(R)+2] + ts[r+(R)+1]; \ + X3 += ks[r+(R)+3] + r+(R) ; \ + ks[r + (R)+4 ] = ks[r+(R)-1]; /* rotate key schedule */\ + ts[r + (R)+2 ] = ts[r+(R)-1]; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); + + for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_256) /* loop thru it */ +#endif + { +#define R256_8_rounds(R) \ + R256(0,1,2,3,R_256_0,8*(R) + 1); \ + R256(0,3,2,1,R_256_1,8*(R) + 2); \ + R256(0,1,2,3,R_256_2,8*(R) + 3); \ + R256(0,3,2,1,R_256_3,8*(R) + 4); \ + I256(2*(R)); \ + R256(0,1,2,3,R_256_4,8*(R) + 5); \ + R256(0,3,2,1,R_256_5,8*(R) + 6); \ + R256(0,1,2,3,R_256_6,8*(R) + 7); \ + R256(0,3,2,1,R_256_7,8*(R) + 8); \ + I256(2*(R)+1); + + R256_8_rounds( 0); + +#define R256_Unroll_R(NN) ((SKEIN_UNROLL_256 == 0 && SKEIN_256_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_256 > (NN))) + + #if R256_Unroll_R( 1) + R256_8_rounds( 1); + #endif + #if R256_Unroll_R( 2) + R256_8_rounds( 2); + #endif + #if R256_Unroll_R( 3) + R256_8_rounds( 3); + #endif + #if R256_Unroll_R( 4) + R256_8_rounds( 4); + #endif + #if R256_Unroll_R( 5) + R256_8_rounds( 5); + #endif + #if R256_Unroll_R( 6) + R256_8_rounds( 6); + #endif + #if R256_Unroll_R( 7) + R256_8_rounds( 7); + #endif + #if R256_Unroll_R( 8) + R256_8_rounds( 8); + #endif + #if R256_Unroll_R( 9) + R256_8_rounds( 9); + #endif + #if R256_Unroll_R(10) + R256_8_rounds(10); + #endif + #if R256_Unroll_R(11) + R256_8_rounds(11); + #endif + #if R256_Unroll_R(12) + R256_8_rounds(12); + #endif + #if R256_Unroll_R(13) + R256_8_rounds(13); + #endif + #if R256_Unroll_R(14) + R256_8_rounds(14); + #endif + #if (SKEIN_UNROLL_256 > 14) +#error "need more unrolling in Skein_256_Process_Block" + #endif + } + /* do the final "feedforward" xor, update context chaining vars */ + ctx->X[0] = X0 ^ w[0]; + ctx->X[1] = X1 ^ w[1]; + ctx->X[2] = X2 ^ w[2]; + ctx->X[3] = X3 ^ w[3]; + + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + ts[1] &= ~SKEIN_T1_FLAG_FIRST; + } + while (--blkCnt); + ctx->h.T[0] = ts[0]; + ctx->h.T[1] = ts[1]; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_256_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein_256_Process_Block_CodeSize) - + ((u08b_t *) Skein_256_Process_Block); + } +uint_t Skein_256_Unroll_Cnt(void) + { + return SKEIN_UNROLL_256; + } +#endif +#endif + +/***************************** Skein_512 ******************************/ +#if !(SKEIN_USE_ASM & 512) +void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C */ + enum + { + WCNT = SKEIN_512_STATE_WORDS + }; +#undef RCNT +#define RCNT (SKEIN_512_ROUNDS_TOTAL/8) + +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */ +#define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10) +#else +#define SKEIN_UNROLL_512 (0) +#endif + +#if SKEIN_UNROLL_512 +#if (RCNT % SKEIN_UNROLL_512) +#error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */ +#endif + size_t r; + u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ +#else + u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ +#endif + u64b_t X0,X1,X2,X3,X4,X5,X6,X7; /* local copy of vars, for speed */ + u64b_t w [WCNT]; /* local copy of input block */ +#ifdef SKEIN_DEBUG + const u64b_t *Xptr[8]; /* use for debugging (help compiler put Xn in registers) */ + Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; + Xptr[4] = &X4; Xptr[5] = &X5; Xptr[6] = &X6; Xptr[7] = &X7; +#endif + + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ts[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[0] = ctx->X[0]; + ks[1] = ctx->X[1]; + ks[2] = ctx->X[2]; + ks[3] = ctx->X[3]; + ks[4] = ctx->X[4]; + ks[5] = ctx->X[5]; + ks[6] = ctx->X[6]; + ks[7] = ctx->X[7]; + ks[8] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ + ks[4] ^ ks[5] ^ ks[6] ^ ks[7] ^ SKEIN_KS_PARITY; + + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + DebugSaveTweak(ctx); + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + + X0 = w[0] + ks[0]; /* do the first full key injection */ + X1 = w[1] + ks[1]; + X2 = w[2] + ks[2]; + X3 = w[3] + ks[3]; + X4 = w[4] + ks[4]; + X5 = w[5] + ks[5] + ts[0]; + X6 = w[6] + ks[6] + ts[1]; + X7 = w[7] + ks[7]; + + blkPtr += SKEIN_512_BLOCK_BYTES; + + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); + /* run the rounds */ +#define Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ + 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##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; \ + +#if SKEIN_UNROLL_512 == 0 +#define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) /* unrolled */ \ + Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); + +#define I512(R) \ + X0 += ks[((R)+1) % 9]; /* inject the key schedule value */ \ + X1 += ks[((R)+2) % 9]; \ + X2 += ks[((R)+3) % 9]; \ + X3 += ks[((R)+4) % 9]; \ + X4 += ks[((R)+5) % 9]; \ + X5 += ks[((R)+6) % 9] + ts[((R)+1) % 3]; \ + X6 += ks[((R)+7) % 9] + ts[((R)+2) % 3]; \ + X7 += ks[((R)+8) % 9] + (R)+1; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); +#else /* looping version */ +#define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ + Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); + +#define I512(R) \ + X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ + X1 += ks[r+(R)+1]; \ + X2 += ks[r+(R)+2]; \ + X3 += ks[r+(R)+3]; \ + X4 += ks[r+(R)+4]; \ + X5 += ks[r+(R)+5] + ts[r+(R)+0]; \ + X6 += ks[r+(R)+6] + ts[r+(R)+1]; \ + X7 += ks[r+(R)+7] + r+(R) ; \ + ks[r + (R)+8] = ks[r+(R)-1]; /* rotate key schedule */ \ + ts[r + (R)+2] = ts[r+(R)-1]; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); + + for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_512) /* loop thru it */ +#endif /* end of looped code definitions */ + { +#define R512_8_rounds(R) /* do 8 full rounds */ \ + 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(4,1,6,3,0,5,2,7,R_512_2,8*(R)+ 3); \ + R512(6,1,0,7,2,5,4,3,R_512_3,8*(R)+ 4); \ + I512(2*(R)); \ + R512(0,1,2,3,4,5,6,7,R_512_4,8*(R)+ 5); \ + R512(2,1,4,7,6,5,0,3,R_512_5,8*(R)+ 6); \ + R512(4,1,6,3,0,5,2,7,R_512_6,8*(R)+ 7); \ + R512(6,1,0,7,2,5,4,3,R_512_7,8*(R)+ 8); \ + I512(2*(R)+1); /* and key injection */ + + R512_8_rounds( 0); + +#define R512_Unroll_R(NN) ((SKEIN_UNROLL_512 == 0 && SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_512 > (NN))) + + #if R512_Unroll_R( 1) + R512_8_rounds( 1); + #endif + #if R512_Unroll_R( 2) + R512_8_rounds( 2); + #endif + #if R512_Unroll_R( 3) + R512_8_rounds( 3); + #endif + #if R512_Unroll_R( 4) + R512_8_rounds( 4); + #endif + #if R512_Unroll_R( 5) + R512_8_rounds( 5); + #endif + #if R512_Unroll_R( 6) + R512_8_rounds( 6); + #endif + #if R512_Unroll_R( 7) + R512_8_rounds( 7); + #endif + #if R512_Unroll_R( 8) + R512_8_rounds( 8); + #endif + #if R512_Unroll_R( 9) + R512_8_rounds( 9); + #endif + #if R512_Unroll_R(10) + R512_8_rounds(10); + #endif + #if R512_Unroll_R(11) + R512_8_rounds(11); + #endif + #if R512_Unroll_R(12) + R512_8_rounds(12); + #endif + #if R512_Unroll_R(13) + R512_8_rounds(13); + #endif + #if R512_Unroll_R(14) + R512_8_rounds(14); + #endif + #if (SKEIN_UNROLL_512 > 14) +#error "need more unrolling in Skein_512_Process_Block" + #endif + } + + /* do the final "feedforward" xor, update context chaining vars */ + ctx->X[0] = X0 ^ w[0]; + ctx->X[1] = X1 ^ w[1]; + ctx->X[2] = X2 ^ w[2]; + ctx->X[3] = X3 ^ w[3]; + ctx->X[4] = X4 ^ w[4]; + ctx->X[5] = X5 ^ w[5]; + ctx->X[6] = X6 ^ w[6]; + ctx->X[7] = X7 ^ w[7]; + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + ts[1] &= ~SKEIN_T1_FLAG_FIRST; + } + while (--blkCnt); + ctx->h.T[0] = ts[0]; + ctx->h.T[1] = ts[1]; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_512_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein_512_Process_Block_CodeSize) - + ((u08b_t *) Skein_512_Process_Block); + } +uint_t Skein_512_Unroll_Cnt(void) + { + return SKEIN_UNROLL_512; + } +#endif +#endif + +/***************************** Skein1024 ******************************/ +#if !(SKEIN_USE_ASM & 1024) +void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C, always looping (unrolled is bigger AND slower!) */ + enum + { + WCNT = SKEIN1024_STATE_WORDS + }; +#undef RCNT +#define RCNT (SKEIN1024_ROUNDS_TOTAL/8) + +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */ +#define SKEIN_UNROLL_1024 ((SKEIN_LOOP)%10) +#else +#define SKEIN_UNROLL_1024 (0) +#endif + +#if (SKEIN_UNROLL_1024 != 0) +#if (RCNT % SKEIN_UNROLL_1024) +#error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */ +#endif + size_t r; + u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ +#else + u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ +#endif + + u64b_t X00,X01,X02,X03,X04,X05,X06,X07, /* local copy of vars, for speed */ + X08,X09,X10,X11,X12,X13,X14,X15; + u64b_t w [WCNT]; /* local copy of input block */ +#ifdef SKEIN_DEBUG + const u64b_t *Xptr[16]; /* use for debugging (help compiler put Xn in registers) */ + Xptr[ 0] = &X00; Xptr[ 1] = &X01; Xptr[ 2] = &X02; Xptr[ 3] = &X03; + Xptr[ 4] = &X04; Xptr[ 5] = &X05; Xptr[ 6] = &X06; Xptr[ 7] = &X07; + Xptr[ 8] = &X08; Xptr[ 9] = &X09; Xptr[10] = &X10; Xptr[11] = &X11; + Xptr[12] = &X12; Xptr[13] = &X13; Xptr[14] = &X14; Xptr[15] = &X15; +#endif + + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ts[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[ 0] = ctx->X[ 0]; + ks[ 1] = ctx->X[ 1]; + ks[ 2] = ctx->X[ 2]; + ks[ 3] = ctx->X[ 3]; + ks[ 4] = ctx->X[ 4]; + ks[ 5] = ctx->X[ 5]; + ks[ 6] = ctx->X[ 6]; + ks[ 7] = ctx->X[ 7]; + ks[ 8] = ctx->X[ 8]; + ks[ 9] = ctx->X[ 9]; + ks[10] = ctx->X[10]; + ks[11] = ctx->X[11]; + ks[12] = ctx->X[12]; + ks[13] = ctx->X[13]; + ks[14] = ctx->X[14]; + ks[15] = ctx->X[15]; + ks[16] = ks[ 0] ^ ks[ 1] ^ ks[ 2] ^ ks[ 3] ^ + ks[ 4] ^ ks[ 5] ^ ks[ 6] ^ ks[ 7] ^ + ks[ 8] ^ ks[ 9] ^ ks[10] ^ ks[11] ^ + ks[12] ^ ks[13] ^ ks[14] ^ ks[15] ^ SKEIN_KS_PARITY; + + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + DebugSaveTweak(ctx); + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + + X00 = w[ 0] + ks[ 0]; /* do the first full key injection */ + X01 = w[ 1] + ks[ 1]; + X02 = w[ 2] + ks[ 2]; + X03 = w[ 3] + ks[ 3]; + X04 = w[ 4] + ks[ 4]; + X05 = w[ 5] + ks[ 5]; + X06 = w[ 6] + ks[ 6]; + X07 = w[ 7] + ks[ 7]; + X08 = w[ 8] + ks[ 8]; + X09 = w[ 9] + ks[ 9]; + X10 = w[10] + ks[10]; + X11 = w[11] + ks[11]; + X12 = w[12] + ks[12]; + X13 = w[13] + ks[13] + ts[0]; + X14 = w[14] + ks[14] + ts[1]; + X15 = w[15] + ks[15]; + + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); + +#define Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rNum) \ + 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##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##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##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; \ + +#if SKEIN_UNROLL_1024 == 0 +#define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ + Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rn,Xptr); + +#define I1024(R) \ + X00 += ks[((R)+ 1) % 17]; /* inject the key schedule value */ \ + X01 += ks[((R)+ 2) % 17]; \ + X02 += ks[((R)+ 3) % 17]; \ + X03 += ks[((R)+ 4) % 17]; \ + X04 += ks[((R)+ 5) % 17]; \ + X05 += ks[((R)+ 6) % 17]; \ + X06 += ks[((R)+ 7) % 17]; \ + X07 += ks[((R)+ 8) % 17]; \ + X08 += ks[((R)+ 9) % 17]; \ + X09 += ks[((R)+10) % 17]; \ + X10 += ks[((R)+11) % 17]; \ + X11 += ks[((R)+12) % 17]; \ + X12 += ks[((R)+13) % 17]; \ + X13 += ks[((R)+14) % 17] + ts[((R)+1) % 3]; \ + X14 += ks[((R)+15) % 17] + ts[((R)+2) % 3]; \ + X15 += ks[((R)+16) % 17] + (R)+1; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); +#else /* looping version */ +#define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ + Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rn,Xptr); + +#define I1024(R) \ + X00 += ks[r+(R)+ 0]; /* inject the key schedule value */ \ + X01 += ks[r+(R)+ 1]; \ + X02 += ks[r+(R)+ 2]; \ + X03 += ks[r+(R)+ 3]; \ + X04 += ks[r+(R)+ 4]; \ + X05 += ks[r+(R)+ 5]; \ + X06 += ks[r+(R)+ 6]; \ + X07 += ks[r+(R)+ 7]; \ + X08 += ks[r+(R)+ 8]; \ + X09 += ks[r+(R)+ 9]; \ + X10 += ks[r+(R)+10]; \ + X11 += ks[r+(R)+11]; \ + X12 += ks[r+(R)+12]; \ + X13 += ks[r+(R)+13] + ts[r+(R)+0]; \ + X14 += ks[r+(R)+14] + ts[r+(R)+1]; \ + X15 += ks[r+(R)+15] + r+(R) ; \ + ks[r + (R)+16] = ks[r+(R)-1]; /* rotate key schedule */ \ + ts[r + (R)+ 2] = ts[r+(R)-1]; \ + Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); + + for (r=1;r <= 2*RCNT;r+=2*SKEIN_UNROLL_1024) /* loop thru it */ +#endif + { +#define R1024_8_rounds(R) /* do 8 full rounds */ \ + R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_0,8*(R) + 1); \ + R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_1,8*(R) + 2); \ + R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_2,8*(R) + 3); \ + R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_3,8*(R) + 4); \ + I1024(2*(R)); \ + R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_4,8*(R) + 5); \ + R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_5,8*(R) + 6); \ + R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_6,8*(R) + 7); \ + R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_7,8*(R) + 8); \ + I1024(2*(R)+1); + + R1024_8_rounds( 0); + +#define R1024_Unroll_R(NN) ((SKEIN_UNROLL_1024 == 0 && SKEIN1024_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_1024 > (NN))) + + #if R1024_Unroll_R( 1) + R1024_8_rounds( 1); + #endif + #if R1024_Unroll_R( 2) + R1024_8_rounds( 2); + #endif + #if R1024_Unroll_R( 3) + R1024_8_rounds( 3); + #endif + #if R1024_Unroll_R( 4) + R1024_8_rounds( 4); + #endif + #if R1024_Unroll_R( 5) + R1024_8_rounds( 5); + #endif + #if R1024_Unroll_R( 6) + R1024_8_rounds( 6); + #endif + #if R1024_Unroll_R( 7) + R1024_8_rounds( 7); + #endif + #if R1024_Unroll_R( 8) + R1024_8_rounds( 8); + #endif + #if R1024_Unroll_R( 9) + R1024_8_rounds( 9); + #endif + #if R1024_Unroll_R(10) + R1024_8_rounds(10); + #endif + #if R1024_Unroll_R(11) + R1024_8_rounds(11); + #endif + #if R1024_Unroll_R(12) + R1024_8_rounds(12); + #endif + #if R1024_Unroll_R(13) + R1024_8_rounds(13); + #endif + #if R1024_Unroll_R(14) + R1024_8_rounds(14); + #endif + #if (SKEIN_UNROLL_1024 > 14) +#error "need more unrolling in Skein_1024_Process_Block" + #endif + } + /* do the final "feedforward" xor, update context chaining vars */ + + ctx->X[ 0] = X00 ^ w[ 0]; + ctx->X[ 1] = X01 ^ w[ 1]; + ctx->X[ 2] = X02 ^ w[ 2]; + ctx->X[ 3] = X03 ^ w[ 3]; + ctx->X[ 4] = X04 ^ w[ 4]; + ctx->X[ 5] = X05 ^ w[ 5]; + ctx->X[ 6] = X06 ^ w[ 6]; + ctx->X[ 7] = X07 ^ w[ 7]; + ctx->X[ 8] = X08 ^ w[ 8]; + ctx->X[ 9] = X09 ^ w[ 9]; + ctx->X[10] = X10 ^ w[10]; + ctx->X[11] = X11 ^ w[11]; + ctx->X[12] = X12 ^ w[12]; + ctx->X[13] = X13 ^ w[13]; + ctx->X[14] = X14 ^ w[14]; + ctx->X[15] = X15 ^ w[15]; + + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + ts[1] &= ~SKEIN_T1_FLAG_FIRST; + blkPtr += SKEIN1024_BLOCK_BYTES; + } + while (--blkCnt); + ctx->h.T[0] = ts[0]; + ctx->h.T[1] = ts[1]; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein1024_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein1024_Process_Block_CodeSize) - + ((u08b_t *) Skein1024_Process_Block); + } +uint_t Skein1024_Unroll_Cnt(void) + { + return SKEIN_UNROLL_1024; + } +#endif +#endif
+ c_impl/optimized/skein_debug.c view
@@ -0,0 +1,230 @@+/*********************************************************************** +** +** Debug output functions for Skein hashing. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ +#include <stdio.h> + +#ifdef SKEIN_DEBUG /* only instantiate this code if SKEIN_DEBUG is on */ +#include "skein.h" + +static const char *INDENT = " "; /* how much to indent on new line */ + +uint_t skein_DebugFlag = 0; /* off by default. Must be set externally */ + +static void Show64(size_t cnt,const u64b_t *X) + { + size_t i; + for (i=0;i < cnt;i++) + { + if (i % 4 == 0) printf(INDENT); + printf(" %08X.%08X ",(uint_32t)(X[i] >> 32),(uint_32t)X[i]); + if (i % 4 == 3 || i==cnt-1) printf("\n"); + } + } + +static void Show08(size_t cnt,const u08b_t *b) + { + size_t i; + for (i=0;i < cnt;i++) + { + if (i %16 == 0) printf(INDENT); + else if (i % 4 == 0) printf(" "); + printf(" %02X",b[i]); + if (i %16 == 15 || i==cnt-1) printf("\n"); + } + } + +static const char *AlgoHeader(uint_t bits) + { + if (skein_DebugFlag & SKEIN_DEBUG_THREEFISH) + switch (bits) + { + case 256: return ":Threefish-256: "; + case 512: return ":Threefish-512: "; + case 1024: return ":Threefish-1024:"; + } + else + switch (bits) + { + case 256: return ":Skein-256: "; + case 512: return ":Skein-512: "; + case 1024: return ":Skein-1024:"; + } + return NULL; + } + +void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr) + { + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag & SKEIN_DEBUG_FINAL) + { + printf("\n%s Final output=\n",AlgoHeader(bits)); + Show08(cnt,outPtr); + printf(" ++++++++++\n"); + } + } + +/* show state after a round (or "pseudo-round") */ +void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X) + { + static uint_t injectNum=0; /* not multi-thread safe! */ + + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag) + { + if (r >= SKEIN_RND_SPECIAL) + { /* a key injection (or feedforward) point */ + injectNum = (r == SKEIN_RND_KEY_INITIAL) ? 0 : injectNum+1; + if ( skein_DebugFlag & SKEIN_DEBUG_INJECT || + ((skein_DebugFlag & SKEIN_DEBUG_FINAL) && r == SKEIN_RND_FEED_FWD)) + { + printf("\n%s",AlgoHeader(bits)); + switch (r) + { + case SKEIN_RND_KEY_INITIAL: + printf(" [state after initial key injection]"); + break; + case SKEIN_RND_KEY_INJECT: + printf(" [state after key injection #%02d]",injectNum); + break; + case SKEIN_RND_FEED_FWD: + printf(" [state after plaintext feedforward]"); + injectNum = 0; + break; + } + printf("=\n"); + Show64(bits/64,X); + if (r== SKEIN_RND_FEED_FWD) + printf(" ----------\n"); + } + } + else if (skein_DebugFlag & SKEIN_DEBUG_ROUNDS) + { + uint_t j; + u64b_t p[SKEIN_MAX_STATE_WORDS]; + const u08b_t *perm; + const static u08b_t PERM_256 [4][ 4] = { { 0,1,2,3 }, { 0,3,2,1 }, { 0,1,2,3 }, { 0,3,2,1 } }; + const static u08b_t PERM_512 [4][ 8] = { { 0,1,2,3,4,5,6,7 }, + { 2,1,4,7,6,5,0,3 }, + { 4,1,6,3,0,5,2,7 }, + { 6,1,0,7,2,5,4,3 } + }; + const static u08b_t PERM_1024[4][16] = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 }, + { 0, 9, 2,13, 6,11, 4,15,10, 7,12, 3,14, 5, 8, 1 }, + { 0, 7, 2, 5, 4, 3, 6, 1,12,15,14,13, 8,11,10, 9 }, + { 0,15, 2,11, 6,13, 4, 9,14, 1, 8, 5,10, 3,12, 7 } + }; + + if ((skein_DebugFlag & SKEIN_DEBUG_PERMUTE) && (r & 3)) + { + printf("\n%s [state after round %2d (permuted)]=\n",AlgoHeader(bits),r); + switch (bits) + { + case 256: perm = PERM_256 [r&3]; break; + case 512: perm = PERM_512 [r&3]; break; + default: perm = PERM_1024[r&3]; break; + } + for (j=0;j<bits/64;j++) + p[j] = X[perm[j]]; + Show64(bits/64,p); + } + else + { + printf("\n%s [state after round %2d]=\n",AlgoHeader(bits),r); + Show64(bits/64,X); + } + } + } + } + +/* show state after a round (or "pseudo-round"), given a list of pointers */ +void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]) + { + uint_t i; + u64b_t X[SKEIN_MAX_STATE_WORDS]; + + for (i=0;i<bits/64;i++) /* copy over the words */ + X[i] = X_ptr[i][0]; + Skein_Show_Round(bits,h,r,X); + } + + +/* show the state at the start of a block */ +void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, + const u64b_t *wPtr, const u64b_t *ksPtr, const u64b_t *tsPtr) + { + uint_t n; + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag) + { + if (skein_DebugFlag & SKEIN_DEBUG_HDR) + { + printf("\n%s Block: outBits=%4d. T0=%06X.",AlgoHeader(bits),(uint_t) h->hashBitLen,(uint_t)h->T[0]); + printf(" Type="); + n = (uint_t) ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) >> SKEIN_T1_POS_BLK_TYPE); + switch (n) + { + case SKEIN_BLK_TYPE_KEY: printf("KEY. "); break; + case SKEIN_BLK_TYPE_CFG: printf("CFG. "); break; + case SKEIN_BLK_TYPE_PERS: printf("PERS."); break; + case SKEIN_BLK_TYPE_PK : printf("PK. "); break; + case SKEIN_BLK_TYPE_KDF: printf("KDF. "); break; + case SKEIN_BLK_TYPE_MSG: printf("MSG. "); break; + case SKEIN_BLK_TYPE_OUT: printf("OUT. "); break; + default: printf("0x%02X.",n); break; + } + printf(" Flags="); + printf((h->T[1] & SKEIN_T1_FLAG_FIRST) ? " First":" "); + printf((h->T[1] & SKEIN_T1_FLAG_FINAL) ? " Final":" "); + printf((h->T[1] & SKEIN_T1_FLAG_BIT_PAD) ? " Pad" :" "); + n = (uint_t) ((h->T[1] & SKEIN_T1_TREE_LVL_MASK) >> SKEIN_T1_POS_TREE_LVL); + if (n) + printf(" TreeLevel = %02X",n); + printf("\n"); + } + if (skein_DebugFlag & SKEIN_DEBUG_TWEAK) + { + printf(" Tweak:\n"); + Show64(2,h->T); + } + if (skein_DebugFlag & SKEIN_DEBUG_STATE) + { + printf(" %s words:\n",(skein_DebugFlag & SKEIN_DEBUG_THREEFISH)?"Key":"State"); + Show64(bits/64,X); + } + if (skein_DebugFlag & SKEIN_DEBUG_KEYSCHED) + { + printf(" Tweak schedule:\n"); + Show64(3,tsPtr); + printf(" Key schedule:\n"); + Show64((bits/64)+1,ksPtr); + } + if (skein_DebugFlag & SKEIN_DEBUG_INPUT_64) + { + printf(" Input block (words):\n"); + Show64(bits/64,wPtr); + } + if (skein_DebugFlag & SKEIN_DEBUG_INPUT_08) + { + printf(" Input block (bytes):\n"); + Show08(bits/8,blkPtr); + } + } + } + +void Skein_Show_Key(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes) + { + if (keyBytes) + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag & SKEIN_DEBUG_KEY) + { + printf("\n%s MAC key = %4u bytes\n",AlgoHeader(bits),keyBytes); + Show08(keyBytes,key); + } + } +#endif
+ c_impl/optimized/skein_debug.h view
@@ -0,0 +1,48 @@+#ifndef _SKEIN_DEBUG_H_ +#define _SKEIN_DEBUG_H_ +/*********************************************************************** +** +** Interface definitions for Skein hashing debug output. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ + +#ifdef SKEIN_DEBUG +/* callout functions used inside Skein code */ +void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, + const u64b_t *wPtr,const u64b_t *ksPtr,const u64b_t *tsPtr); +void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X); +void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]); +void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr); +void Skein_Show_Key (uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes); + +extern uint_t skein_DebugFlag; /* flags to control debug output (0 --> none) */ + +#define SKEIN_RND_SPECIAL (1000u) +#define SKEIN_RND_KEY_INITIAL (SKEIN_RND_SPECIAL+0u) +#define SKEIN_RND_KEY_INJECT (SKEIN_RND_SPECIAL+1u) +#define SKEIN_RND_FEED_FWD (SKEIN_RND_SPECIAL+2u) + +/* flag bits: skein_DebugFlag */ +#define SKEIN_DEBUG_KEY (1u << 1) /* show MAC key */ +#define SKEIN_DEBUG_CONFIG (1u << 2) /* show config block processing */ +#define SKEIN_DEBUG_STATE (1u << 3) /* show input state during Show_Block() */ +#define SKEIN_DEBUG_TWEAK (1u << 4) /* show input state during Show_Block() */ +#define SKEIN_DEBUG_KEYSCHED (1u << 5) /* show expanded key schedule */ +#define SKEIN_DEBUG_INPUT_64 (1u << 6) /* show input block as 64-bit words */ +#define SKEIN_DEBUG_INPUT_08 (1u << 7) /* show input block as 8-bit bytes */ +#define SKEIN_DEBUG_INJECT (1u << 8) /* show state after key injection & feedforward points */ +#define SKEIN_DEBUG_ROUNDS (1u << 9) /* show state after all rounds */ +#define SKEIN_DEBUG_FINAL (1u <<10) /* show final output of Skein */ +#define SKEIN_DEBUG_HDR (1u <<11) /* show block header */ +#define SKEIN_DEBUG_THREEFISH (1u <<12) /* use Threefish name instead of Skein */ +#define SKEIN_DEBUG_PERMUTE (1u <<13) /* use word permutations */ +#define SKEIN_DEBUG_ALL ((~0u) & ~(SKEIN_DEBUG_THREEFISH | SKEIN_DEBUG_PERMUTE)) +#define THREEFISH_DEBUG_ALL (SKEIN_DEBUG_ALL | SKEIN_DEBUG_THREEFISH) + +#endif /* SKEIN_DEBUG */ + +#endif /* _SKEIN_DEBUG_H_ */
+ c_impl/optimized/skein_iv.h view
@@ -0,0 +1,199 @@+#ifndef _SKEIN_IV_H_ +#define _SKEIN_IV_H_ + +#include "skein.h" /* get Skein macros and types */ + +/* +***************** Pre-computed Skein IVs ******************* +** +** NOTE: these values are not "magic" constants, but +** are generated using the Threefish block function. +** They are pre-computed here only for speed; i.e., to +** avoid the need for a Threefish call during Init(). +** +** The IV for any fixed hash length may be pre-computed. +** Only the most common values are included here. +** +************************************************************ +**/ + +#define MK_64 SKEIN_MK_64 + +/* blkSize = 256 bits. hashSize = 128 bits */ +const u64b_t SKEIN_256_IV_128[] = + { + MK_64(0x302F7EA2,0x3D7FE2E1), + MK_64(0xADE4683A,0x6913752B), + MK_64(0x975CFABE,0xF208AB0A), + MK_64(0x2AF4BA95,0xF831F55B) + }; + +/* blkSize = 256 bits. hashSize = 160 bits */ +const u64b_t SKEIN_256_IV_160[] = + { + MK_64(0xA38A0D80,0xA3687723), + MK_64(0xB73CDB6A,0x5963FFC9), + MK_64(0x9633E8EA,0x07A1B447), + MK_64(0xCA0ED09E,0xC9529C22) + }; + +/* blkSize = 256 bits. hashSize = 224 bits */ +const u64b_t SKEIN_256_IV_224[] = + { + MK_64(0xB8092969,0x9AE0F431), + MK_64(0xD340DC14,0xA06929DC), + MK_64(0xAE866594,0xBDE4DC5A), + MK_64(0x339767C2,0x5A60EA1D) + }; + +/* blkSize = 256 bits. hashSize = 256 bits */ +const u64b_t SKEIN_256_IV_256[] = + { + MK_64(0x38851268,0x0E660046), + MK_64(0x4B72D5DE,0xC5A8FF01), + MK_64(0x281A9298,0xCA5EB3A5), + MK_64(0x54CA5249,0xF46070C4) + }; + +/* blkSize = 512 bits. hashSize = 128 bits */ +const u64b_t SKEIN_512_IV_128[] = + { + MK_64(0x477DF9EF,0xAFC4F08A), + MK_64(0x7A64D342,0x33660E14), + MK_64(0x71653C44,0xCEBC89C5), + MK_64(0x63D2A36D,0x65B0AB91), + MK_64(0x52B93FB0,0x9782EA89), + MK_64(0x20F36980,0x8B960829), + MK_64(0xE8DF80FB,0x30303B9B), + MK_64(0xB89D3902,0x1A476D1F) + }; + +/* blkSize = 512 bits. hashSize = 160 bits */ +const u64b_t SKEIN_512_IV_160[] = + { + MK_64(0x0045FA2C,0xAD913A2C), + MK_64(0xF45C9A76,0xBF75CE81), + MK_64(0x0ED758A9,0x3D1F266B), + MK_64(0xC0E65E85,0x1EDCD67A), + MK_64(0x1E024D51,0xF5E7583E), + MK_64(0xA271F855,0x4E52B0E1), + MK_64(0x5292867D,0x8AC674F9), + MK_64(0xADA325FA,0x60C3B226) + }; + +/* blkSize = 512 bits. hashSize = 224 bits */ +const u64b_t SKEIN_512_IV_224[] = + { + MK_64(0xF2DAA169,0x8216CC98), + MK_64(0x00E06A48,0x8983AE05), + MK_64(0xC080CEA9,0x5948958F), + MK_64(0x2A8F314B,0x57F4ADD1), + MK_64(0xBCD06591,0x360A405A), + MK_64(0xF81A11A1,0x02D91F70), + MK_64(0x85C6FFA5,0x4810A739), + MK_64(0x1E07AFE0,0x1802CE74) + }; + +/* blkSize = 512 bits. hashSize = 256 bits */ +const u64b_t SKEIN_512_IV_256[] = + { + MK_64(0x88C07F38,0xD4F95AD4), + MK_64(0x3DF0D33A,0x8610E240), + MK_64(0x3E243F6E,0xDB6FAC74), + MK_64(0xBAC4F4CD,0xD7A90A24), + MK_64(0xDF90FD1F,0xDEEEBA04), + MK_64(0xA4F5796B,0xDB7FDDA8), + MK_64(0xDA182FD2,0x964BC923), + MK_64(0x55F76677,0xEF6961F9) + }; + +/* blkSize = 512 bits. hashSize = 384 bits */ +const u64b_t SKEIN_512_IV_384[] = + { + MK_64(0xE5BF4D02,0xBA62494C), + MK_64(0x7AA1EABC,0xC3E6FC68), + MK_64(0xBBE5FC26,0xE1038C5A), + MK_64(0x53C9903E,0x8F88E9FA), + MK_64(0xF30D8DDD,0xFB940C83), + MK_64(0x500FDA3C,0x4865ABEC), + MK_64(0x2226C67F,0x745BC5E7), + MK_64(0x015DA800,0x77C639F7) + }; + +/* blkSize = 512 bits. hashSize = 512 bits */ +const u64b_t SKEIN_512_IV_512[] = + { + MK_64(0xA8D47980,0x544A6E32), + MK_64(0x84751153,0x3E9B1A8A), + MK_64(0x6FAEE870,0xD8E81A00), + MK_64(0x58B0D9D6,0xCB557F92), + MK_64(0x9BBC0051,0xDAC1D4E9), + MK_64(0xB744E2B1,0xD189E7CA), + MK_64(0x979350FA,0x709C5EF3), + MK_64(0x0350125A,0x92067BCD) + }; + +/* blkSize = 1024 bits. hashSize = 384 bits */ +const u64b_t SKEIN1024_IV_384[] = + { + MK_64(0x7600B2E3,0x9FC73E48), + MK_64(0x7A4543BB,0xECCD60E4), + MK_64(0x8AB879D6,0x2F53E192), + MK_64(0x14847919,0xA7F0AC6E), + MK_64(0x4F774735,0xAA99CB7F), + MK_64(0x607CF3C2,0x41760EE1), + MK_64(0xC0BF6D7B,0xFF9F27DB), + MK_64(0x7D321485,0x99342254), + MK_64(0xE7231BB0,0xCDF9DD49), + MK_64(0x641DE8E6,0x464DB3F4), + MK_64(0x05613046,0xA01CF005), + MK_64(0x7347EE0B,0xB09E8BCC), + MK_64(0x5103A256,0x161A26FF), + MK_64(0x8161EAC4,0x3A1176C2), + MK_64(0xB9607373,0xCF92C2CC), + MK_64(0xFDE8D4AD,0xD376300D) + }; + +/* blkSize = 1024 bits. hashSize = 512 bits */ +const u64b_t SKEIN1024_IV_512[] = + { + MK_64(0x8CF63BE5,0xE1EDF4B7), + MK_64(0x256FD425,0xCBDE61EB), + MK_64(0x497B412D,0xEBA3EF9D), + MK_64(0x3CBD412A,0xD8293FBA), + MK_64(0xD5AE34D6,0xF26F646E), + MK_64(0x72879C01,0x0DA17B79), + MK_64(0x61BD8F18,0x05AFF621), + MK_64(0x75CB3C94,0x9CE0E463), + MK_64(0xAF27329D,0x2CD71E37), + MK_64(0x7DB5EC5E,0x1141CE9F), + MK_64(0x76484C13,0x20CAB67B), + MK_64(0x57EB52A6,0x561BE8C5), + MK_64(0x51161125,0xE681412D), + MK_64(0xF510D937,0x5439A9BC), + MK_64(0xD18AF77C,0xFC425E3C), + MK_64(0xEB05160C,0x3FEBB037) + }; + +/* blkSize = 1024 bits. hashSize = 1024 bits */ +const u64b_t SKEIN1024_IV_1024[] = + { + MK_64(0x5A4352BE,0x62092156), + MK_64(0x5F6E8B1A,0x72F001CA), + MK_64(0xFFCBFE9C,0xA1A2CE26), + MK_64(0x6C23C396,0x67038BCA), + MK_64(0x583A8BFC,0xCE34EB6C), + MK_64(0x3FDBFB11,0xD4A46A3E), + MK_64(0x3304ACFC,0xA8300998), + MK_64(0xB2F6675F,0xA17F0FD2), + MK_64(0x9D259973,0x0EF7AB6B), + MK_64(0x0914A20D,0x3DFEA9E4), + MK_64(0xCC1A9CAF,0xA494DBD3), + MK_64(0x9828030D,0xA0A6388C), + MK_64(0x0D339D5D,0xAADEE3DC), + MK_64(0xFC46DE35,0xC4E2A086), + MK_64(0x53D6E4F5,0x2E19A6D1), + MK_64(0x5663952F,0x715D1DDD) + }; + +#endif /* _SKEIN_IV_H_ */
+ c_impl/optimized/skein_port.h view
@@ -0,0 +1,113 @@+#ifndef _SKEIN_PORT_H_ +#define _SKEIN_PORT_H_ +/******************************************************************* +** +** Platform-specific definitions for Skein hash function. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +** Many thanks to Brian Gladman for his portable header files. +** +** To port Skein to an "unsupported" platform, change the definitions +** in this file appropriately. +** +********************************************************************/ + +/* 2011-09-15: Modified to avoid brg_types and include stdint.h */ +#include <stdint.h> + +typedef unsigned int uint_t; /* native unsigned integer */ +typedef uint8_t u08b_t; /* 8-bit unsigned integer */ +typedef uint64_t u64b_t; /* 64-bit unsigned integer */ + +#ifndef RotL_64 +#define RotL_64(x,N) (((x) << (N)) | ((x) >> (64-(N)))) +#endif + +/* + * Skein is "natively" little-endian (unlike SHA-xxx), for optimal + * performance on x86 CPUs. The Skein code requires the following + * definitions for dealing with endianness: + * + * SKEIN_NEED_SWAP: 0 for little-endian, 1 for big-endian + * Skein_Put64_LSB_First + * Skein_Get64_LSB_First + * Skein_Swap64 + * + * If SKEIN_NEED_SWAP is defined at compile time, it is used here + * along with the portable versions of Put64/Get64/Swap64, which + * are slow in general. + * + * Otherwise, an "auto-detect" of endianness is attempted below. + * If the default handling doesn't work well, the user may insert + * platform-specific code instead (e.g., for big-endian CPUs). + * + */ +#ifndef SKEIN_NEED_SWAP /* compile-time "override" for endianness? */ + +/* 2011-09-15: Modified to not use brg_endian at all. */ +# error Please define SKEIN_NEED_SWAP as (1) or (0). + +#endif /* ifndef SKEIN_NEED_SWAP */ + +/* + ****************************************************************** + * Provide any definitions still needed. + ****************************************************************** + */ +#ifndef Skein_Swap64 /* swap for big-endian, nop for little-endian */ +#if SKEIN_NEED_SWAP +#define Skein_Swap64(w64) \ + ( (( ((u64b_t)(w64)) & 0xFF) << 56) | \ + (((((u64b_t)(w64)) >> 8) & 0xFF) << 48) | \ + (((((u64b_t)(w64)) >>16) & 0xFF) << 40) | \ + (((((u64b_t)(w64)) >>24) & 0xFF) << 32) | \ + (((((u64b_t)(w64)) >>32) & 0xFF) << 24) | \ + (((((u64b_t)(w64)) >>40) & 0xFF) << 16) | \ + (((((u64b_t)(w64)) >>48) & 0xFF) << 8) | \ + (((((u64b_t)(w64)) >>56) & 0xFF) ) ) +#else +#define Skein_Swap64(w64) (w64) +#endif +#endif /* ifndef Skein_Swap64 */ + + +#ifndef Skein_Put64_LSB_First +void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt) +#ifdef SKEIN_PORT_CODE /* instantiate the function code here? */ + { /* this version is fully portable (big-endian or little-endian), but slow */ + size_t n; + + for (n=0;n<bCnt;n++) + dst[n] = (u08b_t) (src[n>>3] >> (8*(n&7))); + } +#else + ; /* output only the function prototype */ +#endif +#endif /* ifndef Skein_Put64_LSB_First */ + + +#ifndef Skein_Get64_LSB_First +void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt) +#ifdef SKEIN_PORT_CODE /* instantiate the function code here? */ + { /* this version is fully portable (big-endian or little-endian), but slow */ + size_t n; + + for (n=0;n<8*wCnt;n+=8) + dst[n/8] = (((u64b_t) src[n ]) ) + + (((u64b_t) src[n+1]) << 8) + + (((u64b_t) src[n+2]) << 16) + + (((u64b_t) src[n+3]) << 24) + + (((u64b_t) src[n+4]) << 32) + + (((u64b_t) src[n+5]) << 40) + + (((u64b_t) src[n+6]) << 48) + + (((u64b_t) src[n+7]) << 56) ; + } +#else + ; /* output only the function prototype */ +#endif +#endif /* ifndef Skein_Get64_LSB_First */ + +#endif /* ifndef _SKEIN_PORT_H_ */
+ c_impl/reference/skein.c view
@@ -0,0 +1,747 @@+/*********************************************************************** +** +** Implementation of the Skein hash function. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ + +#include <string.h> /* get the memcpy/memset functions */ +#include "skein.h" /* get the Skein API definitions */ + +/*****************************************************************/ +/* External function to process blkCnt (nonzero) full block(s) of data. */ +void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); +void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); +void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); + +/*****************************************************************/ +/* Portable (i.e., slow) endianness conversion functions */ +u64b_t Skein_Swap64(u64b_t w64) + { /* instantiate the function body here */ + static const u64b_t ONE = 1; /* use this to check endianness */ + + /* figure out endianness "on-the-fly" */ + if (1 == ((u08b_t *) & ONE)[0]) + return w64; /* little-endian is fast */ + else + return (( w64 & 0xFF) << 56) | /* big-endian is slow */ + (((w64 >> 8) & 0xFF) << 48) | + (((w64 >>16) & 0xFF) << 40) | + (((w64 >>24) & 0xFF) << 32) | + (((w64 >>32) & 0xFF) << 24) | + (((w64 >>40) & 0xFF) << 16) | + (((w64 >>48) & 0xFF) << 8) | + (((w64 >>56) & 0xFF) ) ; + } + +void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt) + { /* this version is fully portable (big-endian or little-endian), but slow */ + size_t n; + + for (n=0;n<bCnt;n++) + dst[n] = (u08b_t) (src[n>>3] >> (8*(n&7))); + } + +void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt) + { /* this version is fully portable (big-endian or little-endian), but slow */ + size_t n; + + for (n=0;n<8*wCnt;n+=8) + dst[n/8] = (((u64b_t) src[n ]) ) + + (((u64b_t) src[n+1]) << 8) + + (((u64b_t) src[n+2]) << 16) + + (((u64b_t) src[n+3]) << 24) + + (((u64b_t) src[n+4]) << 32) + + (((u64b_t) src[n+5]) << 40) + + (((u64b_t) src[n+6]) << 48) + + (((u64b_t) src[n+7]) << 56) ; + } + +/*****************************************************************/ +/* 256-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN_256_STATE_BYTES]; + u64b_t w[SKEIN_256_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + + /* build/process config block for hashing */ + ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + uint_t i; + union + { + u08b_t b[SKEIN_256_STATE_BYTES]; + u64b_t w[SKEIN_256_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein_256_Update(ctx,key,keyBytes); /* hash the key */ + Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ + for (i=0;i<SKEIN_256_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } + + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(256,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); + Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN_256_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ + Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); + msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; + msg += n * SKEIN_256_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_256_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); + Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_256_BLOCK_BYTES) + n = SKEIN_256_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_256_API_CodeSize(void) + { + return ((u08b_t *) Skein_256_API_CodeSize) - + ((u08b_t *) Skein_256_Init); + } +#endif + +/*****************************************************************/ +/* 512-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN_512_STATE_BYTES]; + u64b_t w[SKEIN_512_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + + /* build/process config block for hashing */ + ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + uint_t i; + union + { + u08b_t b[SKEIN_512_STATE_BYTES]; + u64b_t w[SKEIN_512_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein_512_Update(ctx,key,keyBytes); /* hash the key */ + Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ + for (i=0;i<SKEIN_512_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } + + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(512,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); + Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN_512_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ + Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); + msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; + msg += n * SKEIN_512_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_512_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); + + Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate more output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_512_BLOCK_BYTES) + n = SKEIN_512_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_512_API_CodeSize(void) + { + return ((u08b_t *) Skein_512_API_CodeSize) - + ((u08b_t *) Skein_512_Init); + } +#endif + +/*****************************************************************/ +/* 1024-bit Skein */ +/*****************************************************************/ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a straight hashing operation */ +int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) + { + union + { + u08b_t b[SKEIN1024_STATE_BYTES]; + u64b_t w[SKEIN1024_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + + /* build/process config block for hashing */ + ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ + Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); + + /* compute the initial chaining values from config block */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ + Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ + /* Set up to process the data message portion of the hash (default) */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* init the context for a MAC and/or tree hash operation */ +/* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ +int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) + { + uint_t i; + union + { + u08b_t b[SKEIN1024_STATE_BYTES]; + u64b_t w[SKEIN1024_STATE_WORDS]; + } cfg; /* config block */ + + Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); + Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); + + /* compute the initial chaining values ctx->X[], based on key */ + if (keyBytes == 0) /* is there a key? */ + { + memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ + } + else /* here to pre-process a key */ + { + Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); + /* do a mini-Init right here */ + ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ + Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ + memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ + Skein1024_Update(ctx,key,keyBytes); /* hash the key */ + Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ + memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ + for (i=0;i<SKEIN1024_STATE_WORDS;i++) /* convert key bytes to context words */ + ctx->X[i] = Skein_Swap64(ctx->X[i]); + } + + /* build/process the config block, type == CONFIG (could be precomputed for each key) */ + ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ + Skein_Start_New_Type(ctx,CFG_FINAL); + + memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ + cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); + cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ + cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ + + Skein_Show_Key(1024,&ctx->h,key,keyBytes); + + /* compute the initial chaining values from config block */ + Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); + + /* The chaining vars ctx->X are now initialized */ + /* Set up to process the data message portion of the hash */ + Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* process the input bytes */ +int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) + { + size_t n; + + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* process full blocks, if any */ + if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) + { + if (ctx->h.bCnt) /* finish up any buffered message data */ + { + n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ + if (n) + { + Skein_assert(n < msgByteCnt); /* check on our logic here */ + memcpy(&ctx->b[ctx->h.bCnt],msg,n); + msgByteCnt -= n; + msg += n; + ctx->h.bCnt += n; + } + Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); + Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); + ctx->h.bCnt = 0; + } + /* now process any remaining full blocks, directly from input message data */ + if (msgByteCnt > SKEIN1024_BLOCK_BYTES) + { + n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ + Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); + msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; + msg += n * SKEIN1024_BLOCK_BYTES; + } + Skein_assert(ctx->h.bCnt == 0); + } + + /* copy any remaining source message data bytes into b[] */ + if (msgByteCnt) + { + Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); + memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); + ctx->h.bCnt += msgByteCnt; + } + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the result */ +int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN1024_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); + + Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN1024_BLOCK_BYTES) + n = SKEIN1024_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein1024_API_CodeSize(void) + { + return ((u08b_t *) Skein1024_API_CodeSize) - + ((u08b_t *) Skein1024_Init); + } +#endif + +#if SKEIN_TREE_HASH +/**************** Functions to support tree hashing ***************/ +/* (this code is identical for Optimized and Reference versions) */ + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); + Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); + Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* finalize the hash computation and output the block, no OUTPUT stage */ +int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ + if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ + memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); + Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ + + Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ + + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_256_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_256_BLOCK_BYTES) + n = SKEIN_256_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN_512_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN_512_BLOCK_BYTES) + n = SKEIN_512_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } + +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* just do the OUTPUT stage */ +int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) + { + size_t i,n,byteCnt; + u64b_t X[SKEIN1024_STATE_WORDS]; + Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ + + /* now output the result */ + byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ + + /* run Threefish in "counter mode" to generate output */ + memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ + memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ + for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) + { + ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ + Skein_Start_New_Type(ctx,OUT_FINAL); + Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ + n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ + if (n >= SKEIN1024_BLOCK_BYTES) + n = SKEIN1024_BLOCK_BYTES; + Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ + Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); + memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ + } + return SKEIN_SUCCESS; + } +#endif
+ c_impl/reference/skein.h view
@@ -0,0 +1,315 @@+#ifndef _SKEIN_H_ +#define _SKEIN_H_ 1 +/************************************************************************** +** +** Interface declarations and internal definitions for Skein hashing. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +*************************************************************************** +** +** The following compile-time switches may be defined to control some +** tradeoffs between speed, code size, error checking, and security. +** +** The "default" note explains what happens when the switch is not defined. +** +** SKEIN_DEBUG -- make callouts from inside Skein code +** to examine/display intermediate values. +** [default: no callouts (no overhead)] +** +** SKEIN_ERR_CHECK -- how error checking is handled inside Skein +** code. If not defined, most error checking +** is disabled (for performance). Otherwise, +** the switch value is interpreted as: +** 0: use assert() to flag errors +** 1: return SKEIN_FAIL to flag errors +** +***************************************************************************/ + +#include <stddef.h> /* get size_t definition */ +#include "skein_port.h" /* get platform-specific definitions */ + +enum + { + SKEIN_SUCCESS = 0, /* return codes from Skein calls */ + SKEIN_FAIL = 1, + SKEIN_BAD_HASHLEN = 2 + }; + +#define SKEIN_MODIFIER_WORDS ( 2) /* number of modifier (tweak) words */ + +#define SKEIN_256_STATE_WORDS ( 4) +#define SKEIN_512_STATE_WORDS ( 8) +#define SKEIN1024_STATE_WORDS (16) +#define SKEIN_MAX_STATE_WORDS (16) + +#define SKEIN_256_STATE_BYTES ( 8*SKEIN_256_STATE_WORDS) +#define SKEIN_512_STATE_BYTES ( 8*SKEIN_512_STATE_WORDS) +#define SKEIN1024_STATE_BYTES ( 8*SKEIN1024_STATE_WORDS) + +#define SKEIN_256_STATE_BITS (64*SKEIN_256_STATE_WORDS) +#define SKEIN_512_STATE_BITS (64*SKEIN_512_STATE_WORDS) +#define SKEIN1024_STATE_BITS (64*SKEIN1024_STATE_WORDS) + +#define SKEIN_256_BLOCK_BYTES ( 8*SKEIN_256_STATE_WORDS) +#define SKEIN_512_BLOCK_BYTES ( 8*SKEIN_512_STATE_WORDS) +#define SKEIN1024_BLOCK_BYTES ( 8*SKEIN1024_STATE_WORDS) + +typedef struct + { + size_t hashBitLen; /* size of hash result, in bits */ + size_t bCnt; /* current byte count in buffer b[] */ + u64b_t T[SKEIN_MODIFIER_WORDS]; /* tweak words: T[0]=byte cnt, T[1]=flags */ + } Skein_Ctxt_Hdr_t; + +typedef struct /* 256-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN_256_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN_256_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein_256_Ctxt_t; + +typedef struct /* 512-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN_512_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN_512_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein_512_Ctxt_t; + +typedef struct /* 1024-bit Skein hash context structure */ + { + Skein_Ctxt_Hdr_t h; /* common header context variables */ + u64b_t X[SKEIN1024_STATE_WORDS]; /* chaining variables */ + u08b_t b[SKEIN1024_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ + } Skein1024_Ctxt_t; + +/* Skein APIs for (incremental) "straight hashing" */ +int Skein_256_Init (Skein_256_Ctxt_t *ctx, size_t hashBitLen); +int Skein_512_Init (Skein_512_Ctxt_t *ctx, size_t hashBitLen); +int Skein1024_Init (Skein1024_Ctxt_t *ctx, size_t hashBitLen); + +int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); +int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); +int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); + +int Skein_256_Final (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Final (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Final (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); + +/* +** Skein APIs for "extended" initialization: MAC keys, tree hashing. +** After an InitExt() call, just use Update/Final calls as with Init(). +** +** 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 +** 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 +** to precompute the MAC IV, then a copy of the context saved and +** reused for each new MAC computation. +**/ +int Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); +int Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); +int Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *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 +*/ +int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t * hashVal); + +#ifndef SKEIN_TREE_HASH +#define SKEIN_TREE_HASH (1) +#endif +#if SKEIN_TREE_HASH +int Skein_256_Output (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); +int Skein_512_Output (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); +int Skein1024_Output (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); +#endif + +/***************************************************************** +** "Internal" Skein definitions +** -- not needed for sequential hashing API, but will be +** helpful for other uses of Skein (e.g., tree hash mode). +** -- included here so that they can be shared between +** reference and optimized code. +******************************************************************/ + +/* tweak word T[1]: bit field starting positions */ +#define SKEIN_T1_BIT(BIT) ((BIT) - 64) /* offset 64 because it's the second word */ + +#define SKEIN_T1_POS_TREE_LVL SKEIN_T1_BIT(112) /* bits 112..118: level in hash tree */ +#define SKEIN_T1_POS_BIT_PAD SKEIN_T1_BIT(119) /* bit 119 : partial final input byte */ +#define SKEIN_T1_POS_BLK_TYPE SKEIN_T1_BIT(120) /* bits 120..125: type field */ +#define SKEIN_T1_POS_FIRST SKEIN_T1_BIT(126) /* bits 126 : first block flag */ +#define SKEIN_T1_POS_FINAL SKEIN_T1_BIT(127) /* bit 127 : final block flag */ + +/* tweak word T[1]: flag bit definition(s) */ +#define SKEIN_T1_FLAG_FIRST (((u64b_t) 1 ) << SKEIN_T1_POS_FIRST) +#define SKEIN_T1_FLAG_FINAL (((u64b_t) 1 ) << SKEIN_T1_POS_FINAL) +#define SKEIN_T1_FLAG_BIT_PAD (((u64b_t) 1 ) << SKEIN_T1_POS_BIT_PAD) + +/* tweak word T[1]: tree level bit field mask */ +#define SKEIN_T1_TREE_LVL_MASK (((u64b_t)0x7F) << SKEIN_T1_POS_TREE_LVL) +#define SKEIN_T1_TREE_LEVEL(n) (((u64b_t) (n)) << SKEIN_T1_POS_TREE_LVL) + +/* tweak word T[1]: block type field */ +#define SKEIN_BLK_TYPE_KEY ( 0) /* key, for MAC and KDF */ +#define SKEIN_BLK_TYPE_CFG ( 4) /* configuration block */ +#define SKEIN_BLK_TYPE_PERS ( 8) /* personalization string */ +#define SKEIN_BLK_TYPE_PK (12) /* public key (for digital signature hashing) */ +#define SKEIN_BLK_TYPE_KDF (16) /* key identifier for KDF */ +#define SKEIN_BLK_TYPE_NONCE (20) /* nonce for PRNG */ +#define SKEIN_BLK_TYPE_MSG (48) /* message processing */ +#define SKEIN_BLK_TYPE_OUT (63) /* output stage */ +#define SKEIN_BLK_TYPE_MASK (63) /* bit field mask */ + +#define SKEIN_T1_BLK_TYPE(T) (((u64b_t) (SKEIN_BLK_TYPE_##T)) << SKEIN_T1_POS_BLK_TYPE) +#define SKEIN_T1_BLK_TYPE_KEY SKEIN_T1_BLK_TYPE(KEY) /* key, for MAC and KDF */ +#define SKEIN_T1_BLK_TYPE_CFG SKEIN_T1_BLK_TYPE(CFG) /* configuration block */ +#define SKEIN_T1_BLK_TYPE_PERS SKEIN_T1_BLK_TYPE(PERS) /* personalization string */ +#define SKEIN_T1_BLK_TYPE_PK SKEIN_T1_BLK_TYPE(PK) /* public key (for digital signature hashing) */ +#define SKEIN_T1_BLK_TYPE_KDF SKEIN_T1_BLK_TYPE(KDF) /* key identifier for KDF */ +#define SKEIN_T1_BLK_TYPE_NONCE SKEIN_T1_BLK_TYPE(NONCE)/* nonce for PRNG */ +#define SKEIN_T1_BLK_TYPE_MSG SKEIN_T1_BLK_TYPE(MSG) /* message processing */ +#define SKEIN_T1_BLK_TYPE_OUT SKEIN_T1_BLK_TYPE(OUT) /* output stage */ +#define SKEIN_T1_BLK_TYPE_MASK SKEIN_T1_BLK_TYPE(MASK) /* field bit mask */ + +#define SKEIN_T1_BLK_TYPE_CFG_FINAL (SKEIN_T1_BLK_TYPE_CFG | SKEIN_T1_FLAG_FINAL) +#define SKEIN_T1_BLK_TYPE_OUT_FINAL (SKEIN_T1_BLK_TYPE_OUT | SKEIN_T1_FLAG_FINAL) + +#define SKEIN_VERSION (1) + +#ifndef SKEIN_ID_STRING_LE /* allow compile-time personalization */ +#define SKEIN_ID_STRING_LE (0x33414853) /* "SHA3" (little-endian)*/ +#endif + +#define SKEIN_MK_64(hi32,lo32) ((lo32) + (((u64b_t) (hi32)) << 32)) +#define SKEIN_SCHEMA_VER SKEIN_MK_64(SKEIN_VERSION,SKEIN_ID_STRING_LE) +#define SKEIN_KS_PARITY SKEIN_MK_64(0x55555555,0x55555555) + +#define SKEIN_CFG_STR_LEN (4*8) + +/* bit field definitions in config block treeInfo word */ +#define SKEIN_CFG_TREE_LEAF_SIZE_POS ( 0) +#define SKEIN_CFG_TREE_NODE_SIZE_POS ( 8) +#define SKEIN_CFG_TREE_MAX_LEVEL_POS (16) + +#define SKEIN_CFG_TREE_LEAF_SIZE_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_LEAF_SIZE_POS) +#define SKEIN_CFG_TREE_NODE_SIZE_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_NODE_SIZE_POS) +#define SKEIN_CFG_TREE_MAX_LEVEL_MSK ((u64b_t) 0xFF) << SKEIN_CFG_TREE_MAX_LEVEL_POS) + +#define SKEIN_CFG_TREE_INFO_SEQUENTIAL (0) /* use as treeInfo in InitExt() call for sequential processing */ +#define SKEIN_CFG_TREE_INFO(leaf,node,maxLevel) ((u64b_t) ((leaf) | ((node) << 8) | ((maxLevel) << 16))) + +/* +** Skein macros for getting/setting tweak words, etc. +** These are useful for partial input bytes, hash tree init/update, etc. +**/ +#define Skein_Get_Tweak(ctxPtr,TWK_NUM) ((ctxPtr)->h.T[TWK_NUM]) +#define Skein_Set_Tweak(ctxPtr,TWK_NUM,tVal) {(ctxPtr)->h.T[TWK_NUM] = (tVal);} + +#define Skein_Get_T0(ctxPtr) Skein_Get_Tweak(ctxPtr,0) +#define Skein_Get_T1(ctxPtr) Skein_Get_Tweak(ctxPtr,1) +#define Skein_Set_T0(ctxPtr,T0) Skein_Set_Tweak(ctxPtr,0,T0) +#define Skein_Set_T1(ctxPtr,T1) Skein_Set_Tweak(ctxPtr,1,T1) + +/* set both tweak words at once */ +#define Skein_Set_T0_T1(ctxPtr,T0,T1) \ + { \ + Skein_Set_T0(ctxPtr,(T0)); \ + Skein_Set_T1(ctxPtr,(T1)); \ + } + +#define Skein_Set_Type(ctxPtr,BLK_TYPE) \ + Skein_Set_T1(ctxPtr,SKEIN_T1_BLK_TYPE_##BLK_TYPE) + +/* set up for starting with a new type: h.T[0]=0; h.T[1] = NEW_TYPE; h.bCnt=0; */ +#define Skein_Start_New_Type(ctxPtr,BLK_TYPE) \ + { Skein_Set_T0_T1(ctxPtr,0,SKEIN_T1_FLAG_FIRST | SKEIN_T1_BLK_TYPE_##BLK_TYPE); (ctxPtr)->h.bCnt=0; } + +#define Skein_Clear_First_Flag(hdr) { (hdr).T[1] &= ~SKEIN_T1_FLAG_FIRST; } +#define Skein_Set_Bit_Pad_Flag(hdr) { (hdr).T[1] |= SKEIN_T1_FLAG_BIT_PAD; } + +#define Skein_Set_Tree_Level(hdr,height) { (hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height);} + +/***************************************************************** +** "Internal" Skein definitions for debugging and error checking +******************************************************************/ +#ifdef SKEIN_DEBUG /* examine/display intermediate values? */ +#include "skein_debug.h" +#else /* default is no callouts */ +#define Skein_Show_Block(bits,ctx,X,blkPtr,wPtr,ksEvenPtr,ksOddPtr) +#define Skein_Show_Round(bits,ctx,r,X) +#define Skein_Show_R_Ptr(bits,ctx,r,X_ptr) +#define Skein_Show_Final(bits,ctx,cnt,outPtr) +#define Skein_Show_Key(bits,ctx,key,keyBytes) +#endif + +#ifndef SKEIN_ERR_CHECK /* run-time checks (e.g., bad params, uninitialized context)? */ +#define Skein_Assert(x,retCode)/* default: ignore all Asserts, for performance */ +#define Skein_assert(x) +#elif defined(SKEIN_ASSERT) +#include <assert.h> +#define Skein_Assert(x,retCode) assert(x) +#define Skein_assert(x) assert(x) +#else +#include <assert.h> +#define Skein_Assert(x,retCode) { if (!(x)) return retCode; } /* caller error */ +#define Skein_assert(x) assert(x) /* internal error */ +#endif + +/***************************************************************** +** Skein block function constants (shared across Ref and Opt code) +******************************************************************/ +enum + { + /* Skein_256 round rotation constants */ + R_256_0_0= 5, R_256_0_1=56, + R_256_1_0=36, R_256_1_1=28, + R_256_2_0=13, R_256_2_1=46, + R_256_3_0=58, R_256_3_1=44, + R_256_4_0=26, R_256_4_1=20, + R_256_5_0=53, R_256_5_1=35, + R_256_6_0=11, R_256_6_1=42, + R_256_7_0=59, R_256_7_1=50, + + /* Skein_512 round rotation constants */ + R_512_0_0=38, R_512_0_1=30, R_512_0_2=50, R_512_0_3=53, + R_512_1_0=48, R_512_1_1=20, R_512_1_2=43, R_512_1_3=31, + R_512_2_0=34, R_512_2_1=14, R_512_2_2=15, R_512_2_3=27, + R_512_3_0=26, R_512_3_1=12, R_512_3_2=58, R_512_3_3= 7, + R_512_4_0=33, R_512_4_1=49, R_512_4_2= 8, R_512_4_3=42, + R_512_5_0=39, R_512_5_1=27, R_512_5_2=41, R_512_5_3=14, + R_512_6_0=29, R_512_6_1=26, R_512_6_2=11, R_512_6_3= 9, + R_512_7_0=33, R_512_7_1=51, R_512_7_2=39, R_512_7_3=35, + + /* Skein1024 round rotation constants */ + R1024_0_0=55, R1024_0_1=43, R1024_0_2=37, R1024_0_3=40, R1024_0_4=16, R1024_0_5=22, R1024_0_6=38, R1024_0_7=12, + R1024_1_0=25, R1024_1_1=25, R1024_1_2=46, R1024_1_3=13, R1024_1_4=14, R1024_1_5=13, R1024_1_6=52, R1024_1_7=57, + R1024_2_0=33, R1024_2_1= 8, R1024_2_2=18, R1024_2_3=57, R1024_2_4=21, R1024_2_5=12, R1024_2_6=32, R1024_2_7=54, + R1024_3_0=34, R1024_3_1=43, R1024_3_2=25, R1024_3_3=60, R1024_3_4=44, R1024_3_5= 9, R1024_3_6=59, R1024_3_7=34, + R1024_4_0=28, R1024_4_1= 7, R1024_4_2=47, R1024_4_3=48, R1024_4_4=51, R1024_4_5= 9, R1024_4_6=35, R1024_4_7=41, + R1024_5_0=17, R1024_5_1= 6, R1024_5_2=18, R1024_5_3=25, R1024_5_4=43, R1024_5_5=42, R1024_5_6=40, R1024_5_7=15, + R1024_6_0=58, R1024_6_1= 7, R1024_6_2=32, R1024_6_3=45, R1024_6_4=19, R1024_6_5=18, R1024_6_6= 2, R1024_6_7=56, + R1024_7_0=47, R1024_7_1=49, R1024_7_2=27, R1024_7_3=58, R1024_7_4=37, R1024_7_5=48, R1024_7_6=53, R1024_7_7=56 + }; + +#ifndef SKEIN_ROUNDS +#define SKEIN_256_ROUNDS_TOTAL (72) /* number of rounds for the different block sizes */ +#define SKEIN_512_ROUNDS_TOTAL (72) +#define SKEIN1024_ROUNDS_TOTAL (80) +#else /* allow command-line define in range 8*(5..14) */ +#define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5)) +#define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/ 10) + 5) % 10) + 5)) +#define SKEIN1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS ) + 5) % 10) + 5)) +#endif + +#endif /* ifndef _SKEIN_H_ */
+ c_impl/reference/skein_block.c view
@@ -0,0 +1,369 @@+/*********************************************************************** +** +** Implementation of the Skein block functions. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +** Compile-time switches: +** +** SKEIN_USE_ASM -- set bits (256/512/1024) to select which +** versions use ASM code for block processing +** [default: use C for all block sizes] +** +************************************************************************/ + +#include <string.h> +#include "skein.h" + +/* 64-bit rotate left */ +u64b_t RotL_64(u64b_t x,uint_t N) + { + return (x << (N & 63)) | (x >> ((64-N) & 63)); + } + +#define BLK_BITS (WCNT*64) + +/* macro to perform a key injection (same for all block sizes) */ +#define InjectKey(r) \ + for (i=0;i < WCNT;i++) \ + X[i] += ks[((r)+i) % (WCNT+1)]; \ + X[WCNT-3] += ts[((r)+0) % 3]; \ + X[WCNT-2] += ts[((r)+1) % 3]; \ + X[WCNT-1] += (r); /* avoid slide attacks */ \ + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,X); + +void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C */ + enum + { + WCNT = SKEIN_256_STATE_WORDS + }; + size_t i,r; + u64b_t ts[3]; /* key schedule: tweak */ + u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ + u64b_t X [WCNT]; /* local copy of context vars */ + u64b_t w [WCNT]; /* local copy of input block */ + + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ctx->h.T[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[WCNT] = SKEIN_KS_PARITY; + for (i=0;i < WCNT; i++) + { + ks[i] = ctx->X[i]; + ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ + } + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + for (i=0;i < WCNT; i++) /* do the first full key injection */ + { + X[i] = w[i] + ks[i]; + } + X[WCNT-3] += ts[0]; + X[WCNT-2] += ts[1]; + + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ + + for (r=1;r <= SKEIN_256_ROUNDS_TOTAL/8; r++) + { /* unroll 8 rounds */ + X[0] += X[1]; X[1] = RotL_64(X[1],R_256_0_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_256_0_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); + + X[0] += X[3]; X[3] = RotL_64(X[3],R_256_1_0); X[3] ^= X[0]; + X[2] += X[1]; X[1] = RotL_64(X[1],R_256_1_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); + + X[0] += X[1]; X[1] = RotL_64(X[1],R_256_2_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_256_2_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); + + X[0] += X[3]; X[3] = RotL_64(X[3],R_256_3_0); X[3] ^= X[0]; + X[2] += X[1]; X[1] = RotL_64(X[1],R_256_3_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); + InjectKey(2*r-1); + + X[0] += X[1]; X[1] = RotL_64(X[1],R_256_4_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_256_4_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); + + X[0] += X[3]; X[3] = RotL_64(X[3],R_256_5_0); X[3] ^= X[0]; + X[2] += X[1]; X[1] = RotL_64(X[1],R_256_5_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); + + X[0] += X[1]; X[1] = RotL_64(X[1],R_256_6_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_256_6_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); + + X[0] += X[3]; X[3] = RotL_64(X[3],R_256_7_0); X[3] ^= X[0]; + X[2] += X[1]; X[1] = RotL_64(X[1],R_256_7_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); + InjectKey(2*r); + } + /* do the final "feedforward" xor, update context chaining vars */ + for (i=0;i < WCNT;i++) + ctx->X[i] = X[i] ^ w[i]; + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ + blkPtr += SKEIN_256_BLOCK_BYTES; + } + while (--blkCnt); + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_256_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein_256_Process_Block_CodeSize) - + ((u08b_t *) Skein_256_Process_Block); + } +uint_t Skein_256_Unroll_Cnt(void) + { + return 1; + } +#endif + +void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C */ + enum + { + WCNT = SKEIN_512_STATE_WORDS + }; + + size_t i,r; + u64b_t ts[3]; /* key schedule: tweak */ + u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ + u64b_t X [WCNT]; /* local copy of vars */ + u64b_t w [WCNT]; /* local copy of input block */ + + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ctx->h.T[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[WCNT] = SKEIN_KS_PARITY; + for (i=0;i < WCNT; i++) + { + ks[i] = ctx->X[i]; + ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ + } + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + for (i=0;i < WCNT; i++) /* do the first full key injection */ + { + X[i] = w[i] + ks[i]; + } + X[WCNT-3] += ts[0]; + X[WCNT-2] += ts[1]; + + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); + for (r=1;r <= SKEIN_512_ROUNDS_TOTAL/8; r++) + { /* unroll 8 rounds */ + X[0] += X[1]; X[1] = RotL_64(X[1],R_512_0_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_512_0_1); X[3] ^= X[2]; + X[4] += X[5]; X[5] = RotL_64(X[5],R_512_0_2); X[5] ^= X[4]; + X[6] += X[7]; X[7] = RotL_64(X[7],R_512_0_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); + + X[2] += X[1]; X[1] = RotL_64(X[1],R_512_1_0); X[1] ^= X[2]; + X[4] += X[7]; X[7] = RotL_64(X[7],R_512_1_1); X[7] ^= X[4]; + X[6] += X[5]; X[5] = RotL_64(X[5],R_512_1_2); X[5] ^= X[6]; + X[0] += X[3]; X[3] = RotL_64(X[3],R_512_1_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); + + X[4] += X[1]; X[1] = RotL_64(X[1],R_512_2_0); X[1] ^= X[4]; + X[6] += X[3]; X[3] = RotL_64(X[3],R_512_2_1); X[3] ^= X[6]; + X[0] += X[5]; X[5] = RotL_64(X[5],R_512_2_2); X[5] ^= X[0]; + X[2] += X[7]; X[7] = RotL_64(X[7],R_512_2_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); + + X[6] += X[1]; X[1] = RotL_64(X[1],R_512_3_0); X[1] ^= X[6]; + X[0] += X[7]; X[7] = RotL_64(X[7],R_512_3_1); X[7] ^= X[0]; + X[2] += X[5]; X[5] = RotL_64(X[5],R_512_3_2); X[5] ^= X[2]; + X[4] += X[3]; X[3] = RotL_64(X[3],R_512_3_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); + InjectKey(2*r-1); + + X[0] += X[1]; X[1] = RotL_64(X[1],R_512_4_0); X[1] ^= X[0]; + X[2] += X[3]; X[3] = RotL_64(X[3],R_512_4_1); X[3] ^= X[2]; + X[4] += X[5]; X[5] = RotL_64(X[5],R_512_4_2); X[5] ^= X[4]; + X[6] += X[7]; X[7] = RotL_64(X[7],R_512_4_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); + + X[2] += X[1]; X[1] = RotL_64(X[1],R_512_5_0); X[1] ^= X[2]; + X[4] += X[7]; X[7] = RotL_64(X[7],R_512_5_1); X[7] ^= X[4]; + X[6] += X[5]; X[5] = RotL_64(X[5],R_512_5_2); X[5] ^= X[6]; + X[0] += X[3]; X[3] = RotL_64(X[3],R_512_5_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); + + X[4] += X[1]; X[1] = RotL_64(X[1],R_512_6_0); X[1] ^= X[4]; + X[6] += X[3]; X[3] = RotL_64(X[3],R_512_6_1); X[3] ^= X[6]; + X[0] += X[5]; X[5] = RotL_64(X[5],R_512_6_2); X[5] ^= X[0]; + X[2] += X[7]; X[7] = RotL_64(X[7],R_512_6_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); + + X[6] += X[1]; X[1] = RotL_64(X[1],R_512_7_0); X[1] ^= X[6]; + X[0] += X[7]; X[7] = RotL_64(X[7],R_512_7_1); X[7] ^= X[0]; + X[2] += X[5]; X[5] = RotL_64(X[5],R_512_7_2); X[5] ^= X[2]; + X[4] += X[3]; X[3] = RotL_64(X[3],R_512_7_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); + InjectKey(2*r); + } + /* do the final "feedforward" xor, update context chaining vars */ + for (i=0;i < WCNT;i++) + ctx->X[i] = X[i] ^ w[i]; + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ + blkPtr += SKEIN_512_BLOCK_BYTES; + } + while (--blkCnt); + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein_512_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein_512_Process_Block_CodeSize) - + ((u08b_t *) Skein_512_Process_Block); + } +uint_t Skein_512_Unroll_Cnt(void) + { + return 1; + } +#endif + +void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) + { /* do it in C */ + enum + { + WCNT = SKEIN1024_STATE_WORDS + }; + + size_t i,r; + u64b_t ts[3]; /* key schedule: tweak */ + u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ + u64b_t X [WCNT]; /* local copy of vars */ + u64b_t w [WCNT]; /* local copy of input block */ + + Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ + do { + /* this implementation only supports 2**64 input bytes (no carry out here) */ + ctx->h.T[0] += byteCntAdd; /* update processed length */ + + /* precompute the key schedule for this block */ + ks[WCNT] = SKEIN_KS_PARITY; + for (i=0;i < WCNT; i++) + { + ks[i] = ctx->X[i]; + ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ + } + ts[0] = ctx->h.T[0]; + ts[1] = ctx->h.T[1]; + ts[2] = ts[0] ^ ts[1]; + + Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ + Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); + for (i=0;i < WCNT; i++) /* do the first full key injection */ + { + X[i] = w[i] + ks[i]; + } + X[WCNT-3] += ts[0]; + X[WCNT-2] += ts[1]; + + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ + for (r=1;r <= SKEIN1024_ROUNDS_TOTAL/8; r++) + { /* unroll 8 rounds */ + X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_0_0); X[ 1] ^= X[ 0]; + X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_0_1); X[ 3] ^= X[ 2]; + X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_0_2); X[ 5] ^= X[ 4]; + X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_0_3); X[ 7] ^= X[ 6]; + X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_0_4); X[ 9] ^= X[ 8]; + X[10] += X[11]; X[11] = RotL_64(X[11],R1024_0_5); X[11] ^= X[10]; + X[12] += X[13]; X[13] = RotL_64(X[13],R1024_0_6); X[13] ^= X[12]; + X[14] += X[15]; X[15] = RotL_64(X[15],R1024_0_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); + + X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_1_0); X[ 9] ^= X[ 0]; + X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_1_1); X[13] ^= X[ 2]; + X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_1_2); X[11] ^= X[ 6]; + X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_1_3); X[15] ^= X[ 4]; + X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_1_4); X[ 7] ^= X[10]; + X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_1_5); X[ 3] ^= X[12]; + X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_1_6); X[ 5] ^= X[14]; + X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_1_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); + + X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_2_0); X[ 7] ^= X[ 0]; + X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_2_1); X[ 5] ^= X[ 2]; + X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_2_2); X[ 3] ^= X[ 4]; + X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_2_3); X[ 1] ^= X[ 6]; + X[12] += X[15]; X[15] = RotL_64(X[15],R1024_2_4); X[15] ^= X[12]; + X[14] += X[13]; X[13] = RotL_64(X[13],R1024_2_5); X[13] ^= X[14]; + X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_2_6); X[11] ^= X[ 8]; + X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_2_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); + + X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_3_0); X[15] ^= X[ 0]; + X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_3_1); X[11] ^= X[ 2]; + X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_3_2); X[13] ^= X[ 6]; + X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_3_3); X[ 9] ^= X[ 4]; + X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_3_4); X[ 1] ^= X[14]; + X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_3_5); X[ 5] ^= X[ 8]; + X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_3_6); X[ 3] ^= X[10]; + X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_3_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); + InjectKey(2*r-1); + + X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_4_0); X[ 1] ^= X[ 0]; + X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_4_1); X[ 3] ^= X[ 2]; + X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_4_2); X[ 5] ^= X[ 4]; + X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_4_3); X[ 7] ^= X[ 6]; + X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_4_4); X[ 9] ^= X[ 8]; + X[10] += X[11]; X[11] = RotL_64(X[11],R1024_4_5); X[11] ^= X[10]; + X[12] += X[13]; X[13] = RotL_64(X[13],R1024_4_6); X[13] ^= X[12]; + X[14] += X[15]; X[15] = RotL_64(X[15],R1024_4_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); + + X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_5_0); X[ 9] ^= X[ 0]; + X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_5_1); X[13] ^= X[ 2]; + X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_5_2); X[11] ^= X[ 6]; + X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_5_3); X[15] ^= X[ 4]; + X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_5_4); X[ 7] ^= X[10]; + X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_5_5); X[ 3] ^= X[12]; + X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_5_6); X[ 5] ^= X[14]; + X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_5_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); + + X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_6_0); X[ 7] ^= X[ 0]; + X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_6_1); X[ 5] ^= X[ 2]; + X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_6_2); X[ 3] ^= X[ 4]; + X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_6_3); X[ 1] ^= X[ 6]; + X[12] += X[15]; X[15] = RotL_64(X[15],R1024_6_4); X[15] ^= X[12]; + X[14] += X[13]; X[13] = RotL_64(X[13],R1024_6_5); X[13] ^= X[14]; + X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_6_6); X[11] ^= X[ 8]; + X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_6_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); + + X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_7_0); X[15] ^= X[ 0]; + X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_7_1); X[11] ^= X[ 2]; + X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_7_2); X[13] ^= X[ 6]; + X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_7_3); X[ 9] ^= X[ 4]; + X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_7_4); X[ 1] ^= X[14]; + X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_7_5); X[ 5] ^= X[ 8]; + X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_7_6); X[ 3] ^= X[10]; + X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_7_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); + InjectKey(2*r); + } + /* do the final "feedforward" xor, update context chaining vars */ + for (i=0;i<WCNT;i++) + ctx->X[i] = X[i] ^ w[i]; + Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); + + Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ + blkPtr += SKEIN1024_BLOCK_BYTES; + } + while (--blkCnt); + } + +#if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) +size_t Skein1024_Process_Block_CodeSize(void) + { + return ((u08b_t *) Skein1024_Process_Block_CodeSize) - + ((u08b_t *) Skein1024_Process_Block); + } +uint_t Skein1024_Unroll_Cnt(void) + { + return 1; + } +#endif
+ c_impl/reference/skein_debug.c view
@@ -0,0 +1,230 @@+/*********************************************************************** +** +** Debug output functions for Skein hashing. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ +#include <stdio.h> + +#ifdef SKEIN_DEBUG /* only instantiate this code if SKEIN_DEBUG is on */ +#include "skein.h" + +static const char *INDENT = " "; /* how much to indent on new line */ + +uint_t skein_DebugFlag = 0; /* off by default. Must be set externally */ + +static void Show64(size_t cnt,const u64b_t *X) + { + size_t i; + for (i=0;i < cnt;i++) + { + if (i % 4 == 0) printf(INDENT); + printf(" %08X.%08X ",(uint_32t)(X[i] >> 32),(uint_32t)X[i]); + if (i % 4 == 3 || i==cnt-1) printf("\n"); + } + } + +static void Show08(size_t cnt,const u08b_t *b) + { + size_t i; + for (i=0;i < cnt;i++) + { + if (i %16 == 0) printf(INDENT); + else if (i % 4 == 0) printf(" "); + printf(" %02X",b[i]); + if (i %16 == 15 || i==cnt-1) printf("\n"); + } + } + +static const char *AlgoHeader(uint_t bits) + { + if (skein_DebugFlag & SKEIN_DEBUG_THREEFISH) + switch (bits) + { + case 256: return ":Threefish-256: "; + case 512: return ":Threefish-512: "; + case 1024: return ":Threefish-1024:"; + } + else + switch (bits) + { + case 256: return ":Skein-256: "; + case 512: return ":Skein-512: "; + case 1024: return ":Skein-1024:"; + } + return NULL; + } + +void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr) + { + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag & SKEIN_DEBUG_FINAL) + { + printf("\n%s Final output=\n",AlgoHeader(bits)); + Show08(cnt,outPtr); + printf(" ++++++++++\n"); + } + } + +/* show state after a round (or "pseudo-round") */ +void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X) + { + static uint_t injectNum=0; /* not multi-thread safe! */ + + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag) + { + if (r >= SKEIN_RND_SPECIAL) + { /* a key injection (or feedforward) point */ + injectNum = (r == SKEIN_RND_KEY_INITIAL) ? 0 : injectNum+1; + if ( skein_DebugFlag & SKEIN_DEBUG_INJECT || + ((skein_DebugFlag & SKEIN_DEBUG_FINAL) && r == SKEIN_RND_FEED_FWD)) + { + printf("\n%s",AlgoHeader(bits)); + switch (r) + { + case SKEIN_RND_KEY_INITIAL: + printf(" [state after initial key injection]"); + break; + case SKEIN_RND_KEY_INJECT: + printf(" [state after key injection #%02d]",injectNum); + break; + case SKEIN_RND_FEED_FWD: + printf(" [state after plaintext feedforward]"); + injectNum = 0; + break; + } + printf("=\n"); + Show64(bits/64,X); + if (r== SKEIN_RND_FEED_FWD) + printf(" ----------\n"); + } + } + else if (skein_DebugFlag & SKEIN_DEBUG_ROUNDS) + { + uint_t j; + u64b_t p[SKEIN_MAX_STATE_WORDS]; + const u08b_t *perm; + const static u08b_t PERM_256 [4][ 4] = { { 0,1,2,3 }, { 0,3,2,1 }, { 0,1,2,3 }, { 0,3,2,1 } }; + const static u08b_t PERM_512 [4][ 8] = { { 0,1,2,3,4,5,6,7 }, + { 2,1,4,7,6,5,0,3 }, + { 4,1,6,3,0,5,2,7 }, + { 6,1,0,7,2,5,4,3 } + }; + const static u08b_t PERM_1024[4][16] = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 }, + { 0, 9, 2,13, 6,11, 4,15,10, 7,12, 3,14, 5, 8, 1 }, + { 0, 7, 2, 5, 4, 3, 6, 1,12,15,14,13, 8,11,10, 9 }, + { 0,15, 2,11, 6,13, 4, 9,14, 1, 8, 5,10, 3,12, 7 } + }; + + if ((skein_DebugFlag & SKEIN_DEBUG_PERMUTE) && (r & 3)) + { + printf("\n%s [state after round %2d (permuted)]=\n",AlgoHeader(bits),r); + switch (bits) + { + case 256: perm = PERM_256 [r&3]; break; + case 512: perm = PERM_512 [r&3]; break; + default: perm = PERM_1024[r&3]; break; + } + for (j=0;j<bits/64;j++) + p[j] = X[perm[j]]; + Show64(bits/64,p); + } + else + { + printf("\n%s [state after round %2d]=\n",AlgoHeader(bits),r); + Show64(bits/64,X); + } + } + } + } + +/* show state after a round (or "pseudo-round"), given a list of pointers */ +void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]) + { + uint_t i; + u64b_t X[SKEIN_MAX_STATE_WORDS]; + + for (i=0;i<bits/64;i++) /* copy over the words */ + X[i] = X_ptr[i][0]; + Skein_Show_Round(bits,h,r,X); + } + + +/* show the state at the start of a block */ +void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, + const u64b_t *wPtr, const u64b_t *ksPtr, const u64b_t *tsPtr) + { + uint_t n; + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag) + { + if (skein_DebugFlag & SKEIN_DEBUG_HDR) + { + printf("\n%s Block: outBits=%4d. T0=%06X.",AlgoHeader(bits),(uint_t) h->hashBitLen,(uint_t)h->T[0]); + printf(" Type="); + n = (uint_t) ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) >> SKEIN_T1_POS_BLK_TYPE); + switch (n) + { + case SKEIN_BLK_TYPE_KEY: printf("KEY. "); break; + case SKEIN_BLK_TYPE_CFG: printf("CFG. "); break; + case SKEIN_BLK_TYPE_PERS: printf("PERS."); break; + case SKEIN_BLK_TYPE_PK : printf("PK. "); break; + case SKEIN_BLK_TYPE_KDF: printf("KDF. "); break; + case SKEIN_BLK_TYPE_MSG: printf("MSG. "); break; + case SKEIN_BLK_TYPE_OUT: printf("OUT. "); break; + default: printf("0x%02X.",n); break; + } + printf(" Flags="); + printf((h->T[1] & SKEIN_T1_FLAG_FIRST) ? " First":" "); + printf((h->T[1] & SKEIN_T1_FLAG_FINAL) ? " Final":" "); + printf((h->T[1] & SKEIN_T1_FLAG_BIT_PAD) ? " Pad" :" "); + n = (uint_t) ((h->T[1] & SKEIN_T1_TREE_LVL_MASK) >> SKEIN_T1_POS_TREE_LVL); + if (n) + printf(" TreeLevel = %02X",n); + printf("\n"); + } + if (skein_DebugFlag & SKEIN_DEBUG_TWEAK) + { + printf(" Tweak:\n"); + Show64(2,h->T); + } + if (skein_DebugFlag & SKEIN_DEBUG_STATE) + { + printf(" %s words:\n",(skein_DebugFlag & SKEIN_DEBUG_THREEFISH)?"Key":"State"); + Show64(bits/64,X); + } + if (skein_DebugFlag & SKEIN_DEBUG_KEYSCHED) + { + printf(" Tweak schedule:\n"); + Show64(3,tsPtr); + printf(" Key schedule:\n"); + Show64((bits/64)+1,ksPtr); + } + if (skein_DebugFlag & SKEIN_DEBUG_INPUT_64) + { + printf(" Input block (words):\n"); + Show64(bits/64,wPtr); + } + if (skein_DebugFlag & SKEIN_DEBUG_INPUT_08) + { + printf(" Input block (bytes):\n"); + Show08(bits/8,blkPtr); + } + } + } + +void Skein_Show_Key(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes) + { + if (keyBytes) + if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) + if (skein_DebugFlag & SKEIN_DEBUG_KEY) + { + printf("\n%s MAC key = %4u bytes\n",AlgoHeader(bits),keyBytes); + Show08(keyBytes,key); + } + } +#endif
+ c_impl/reference/skein_debug.h view
@@ -0,0 +1,48 @@+#ifndef _SKEIN_DEBUG_H_ +#define _SKEIN_DEBUG_H_ +/*********************************************************************** +** +** Interface definitions for Skein hashing debug output. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +************************************************************************/ + +#ifdef SKEIN_DEBUG +/* callout functions used inside Skein code */ +void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, + const u64b_t *wPtr,const u64b_t *ksPtr,const u64b_t *tsPtr); +void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X); +void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]); +void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr); +void Skein_Show_Key (uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes); + +extern uint_t skein_DebugFlag; /* flags to control debug output (0 --> none) */ + +#define SKEIN_RND_SPECIAL (1000u) +#define SKEIN_RND_KEY_INITIAL (SKEIN_RND_SPECIAL+0u) +#define SKEIN_RND_KEY_INJECT (SKEIN_RND_SPECIAL+1u) +#define SKEIN_RND_FEED_FWD (SKEIN_RND_SPECIAL+2u) + +/* flag bits: skein_DebugFlag */ +#define SKEIN_DEBUG_KEY (1u << 1) /* show MAC key */ +#define SKEIN_DEBUG_CONFIG (1u << 2) /* show config block processing */ +#define SKEIN_DEBUG_STATE (1u << 3) /* show input state during Show_Block() */ +#define SKEIN_DEBUG_TWEAK (1u << 4) /* show input state during Show_Block() */ +#define SKEIN_DEBUG_KEYSCHED (1u << 5) /* show expanded key schedule */ +#define SKEIN_DEBUG_INPUT_64 (1u << 6) /* show input block as 64-bit words */ +#define SKEIN_DEBUG_INPUT_08 (1u << 7) /* show input block as 8-bit bytes */ +#define SKEIN_DEBUG_INJECT (1u << 8) /* show state after key injection & feedforward points */ +#define SKEIN_DEBUG_ROUNDS (1u << 9) /* show state after all rounds */ +#define SKEIN_DEBUG_FINAL (1u <<10) /* show final output of Skein */ +#define SKEIN_DEBUG_HDR (1u <<11) /* show block header */ +#define SKEIN_DEBUG_THREEFISH (1u <<12) /* use Threefish name instead of Skein */ +#define SKEIN_DEBUG_PERMUTE (1u <<13) /* use word permutations */ +#define SKEIN_DEBUG_ALL ((~0u) & ~(SKEIN_DEBUG_THREEFISH | SKEIN_DEBUG_PERMUTE)) +#define THREEFISH_DEBUG_ALL (SKEIN_DEBUG_ALL | SKEIN_DEBUG_THREEFISH) + +#endif /* SKEIN_DEBUG */ + +#endif /* _SKEIN_DEBUG_H_ */
+ c_impl/reference/skein_port.h view
@@ -0,0 +1,45 @@+#ifndef _SKEIN_PORT_H_ +#define _SKEIN_PORT_H_ +/******************************************************************* +** +** Platform-specific definitions for Skein hash function. +** +** Source code author: Doug Whiting, 2008. +** +** This algorithm and source code is released to the public domain. +** +** Many thanks to Brian Gladman for his portable header files, which +** have been modified slightly here, to handle a few more platforms. +** +** To port Skein to an "unsupported" platform, change the definitions +** in this file appropriately. +** +********************************************************************/ + +/* 2011-09-15: Modified to avoid brg_types and include stdint.h */ +#include <stdint.h> + +typedef unsigned int uint_t; /* native unsigned integer */ +typedef uint8_t u08b_t; /* 8-bit unsigned integer */ +typedef uint64_t u64b_t; /* 64-bit unsigned integer */ + +/* + * Skein is "natively" little-endian (unlike SHA-xxx), for optimal + * performance on x86 CPUs. The Skein code requires the following + * definitions for dealing with endianness: + * + * Skein_Put64_LSB_First + * Skein_Get64_LSB_First + * Skein_Swap64 + * + * In the reference code, these functions are implemented in a + * very portable (and thus slow) fashion, for clarity. See the file + * "skein_port.h" in the Optimized_Code directory for ways to make + * these functions fast(er) on x86 platforms. + */ + +u64b_t Skein_Swap64(u64b_t w64); +void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt); +void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt); + +#endif /* ifndef _SKEIN_PORT_H_ */
+ skein.cabal view
@@ -0,0 +1,122 @@+Cabal-version: >= 1.8+Name: skein+Version: 0.1+Synopsis: Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.+License: BSD3+License-file: LICENSE+Author: Felipe Lessa <felipe.lessa@gmail.com>, Doug Whiting+Maintainer: Felipe Lessa <felipe.lessa@gmail.com>+Category: Cryptography+Build-type: Simple++Description:+ Skein (<http://www.skein-hash.info/>) is a family of fast+ secure cryptographic hash functions designed by Niels+ Ferguson, Stefan Lucks, Bruce Schneier, Doug Whiting, Mihir+ Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker.+ .+ This package uses bindings to the optimized C implementation+ of Skein. We provide a high-level interface (see module+ "Crypto.Skein") to some of the Skein use cases. We also+ provide a low-level interface (see module+ "Crypto.Skein.Internal") should you need to use Skein in a+ different way.+ .+ Currently we have support for Skein as cryptographic hash+ function as Skein as a message authentication code+ (Skein-MAC). For examples of how to use this package, see+ "Crypto.Skein" module documentation.++Extra-source-files:+ c_impl/optimized/skein.c+ c_impl/optimized/skein.h+ c_impl/optimized/skein_block.c+ c_impl/optimized/skein_debug.c+ c_impl/optimized/skein_debug.h+ c_impl/optimized/skein_iv.h+ c_impl/optimized/skein_port.h+ c_impl/reference/skein.c+ c_impl/reference/skein.h+ c_impl/reference/skein_block.c+ c_impl/reference/skein_debug.c+ c_impl/reference/skein_debug.h+ c_impl/reference/skein_port.h++Data-files:+ tests/skein_golden_kat.txt++Source-repository head+ Type: darcs+ Location: http://patch-tag.com/r/felipe/skein++Flag reference+ Description: Use the reference implementation instead of the optimized one.+ Default: False+++Library+ Hs-Source-Dirs: src++ Exposed-modules:+ Crypto.Skein+ Crypto.Skein.Internal++ Build-depends:+ base >= 3 && < 5,+ bytestring >= 0.9 && < 0.10,+ cereal >= 0.3 && < 0.4,+ tagged >= 0.2 && < 0.3,+ crypto-api >= 0.6 && < 0.7++ Build-tools: hsc2hs+ GHC-options: -Wall++ Extensions:+ BangPatterns+ CPP+ ForeignFunctionInterface+ MultiParamTypeClasses++ Includes:+ skein.h++ if arch(i386) || arch(x86_64)+ CC-options: "-DSKEIN_NEED_SWAP=0"+ if arch(ppc) || arch(sparc)+ CC-options: "-DSKEIN_NEED_SWAP=1"++ if flag(reference)+ Include-Dirs:+ c_impl/reference+ C-sources:+ c_impl/reference/skein.c+ c_impl/reference/skein_block.c+ -- c_impl/reference/skein_debug.c -- not used+ else+ Include-Dirs:+ c_impl/optimized+ C-sources:+ c_impl/optimized/skein.c+ c_impl/optimized/skein_block.c+ -- c_impl/optimized/skein_debug.c -- not used+++Test-suite runtests+ Type: exitcode-stdio-1.0+ Build-depends:+ base >= 3 && < 5,+ bytestring >= 0.9 && < 0.10,+ cereal >= 0.3 && < 0.4,+ tagged >= 0.2 && < 0.3,+ crypto-api >= 0.6 && < 0.7,++ filepath == 1.*,+ transformers,+ hspec == 0.6.*,++ -- finally, our own package+ skein+ GHC-options: -Wall+ Hs-source-dirs: tests+ Main-is: runtests.hs+ Other-modules: Paths_skein
+ src/Crypto/Skein.hs view
@@ -0,0 +1,760 @@+-----------------------------------------------------------------------------+-- |+-- Module : Crypto.Skein+-- Copyright : (c) 2011 Felipe A. Lessa+-- License : BSD3 (see LICENSE)+--+-- Maintainer : felipe.lessa@gmail.com+-- Stability : provisional+-- Portability : portable (needs FFI)+--+-- High-level interface for the Skein family of hash functions.+--+-----------------------------------------------------------------------------++module Crypto.Skein+ ( -- * Using this module+ -- $usingMod++ -- ** Skein as a cryptographic hash function+ -- $skeinAsHash++ -- ** Skein as a message authentication code (MAC)+ -- $skeinAsMAC++ -- * About Skein+ -- $about++ -- * Main cryptographic hash functions+ -- $mainHash++ -- ** Skein-512-512+ Skein_512_512+ , Skein_512_512_Ctx+ -- ** Skein-1024-1024+ , Skein_1024_1024+ , Skein_1024_1024_Ctx+ -- ** Skein-256-256+ , Skein_256_256+ , Skein_256_256_Ctx++ -- * Skein-MAC+ -- $skeinmac+ , Key+ , skeinMAC+ , skeinMAC'+ , SkeinMAC (skeinMACCtx)++ -- * Other variants of cryptographic hash functions+ -- $variants++ -- ** Skein-256-128+ , Skein_256_128+ , Skein_256_128_Ctx+ -- ** Skein-256-160+ , Skein_256_160+ , Skein_256_160_Ctx+ -- ** Skein-256-224+ , Skein_256_224+ , Skein_256_224_Ctx++ -- * Skein-512++ -- ** Skein-512-128+ , Skein_512_128+ , Skein_512_128_Ctx+ -- ** Skein-512-160+ , Skein_512_160+ , Skein_512_160_Ctx+ -- ** Skein-512-224+ , Skein_512_224+ , Skein_512_224_Ctx+ -- ** Skein-512-256+ , Skein_512_256+ , Skein_512_256_Ctx+ -- ** Skein-512-384+ , Skein_512_384+ , Skein_512_384_Ctx++ -- * Skein-1024++ -- ** Skein-1024-384+ , Skein_1024_384+ , Skein_1024_384_Ctx+ -- ** Skein-1024-512+ , Skein_1024_512+ , Skein_1024_512_Ctx+ ) where++-- from base+import Control.Monad (unless)+import Foreign+import Foreign.C++-- from bytestring+import qualified Data.ByteString as B+import qualified Data.ByteString.Lazy as L+import qualified Data.ByteString.Internal as BI+import qualified Data.ByteString.Unsafe as BU++-- from cereal+import Data.Serialize++-- from tagged+import Data.Tagged (Tagged(..))++-- from crypto-api+import Crypto.Classes++-- from this package+import Crypto.Skein.Internal++----------------------------------------------------------------------++-- $usingMod+--+-- Currently this module provides both Skein as a cryptographic+-- hash function and Skein as a MAC. This module currently does+-- not provide some Skein functions, such as tree hashing,+-- pseudo-random number generation, stream ciphing or key+-- derivation.+--+-- Terminology note: we say \"message\" for your variable-sized+-- data that is given to Skein.++-- $skeinAsHash+--+-- There are many variants of Skein as a cryptographic hash+-- function. They are called @Skein_X_Y@, where @X@ is internal+-- state size in bits and @Y@ is the output size in bits. The+-- main ones are 'Skein_512_512', 'Skein_1024_1024' and+-- 'Skein_256_256'. If you are unsure, then use 'Skein_512_512'.+--+-- To use these data types, you have to use 'Hash' and+-- 'Serialize'. Suppose you wanted to hash a lazy 'L.ByteString'+-- @bs@. Then you could use+--+-- @+-- digest :: 'S.ByteString'+-- digest = let h = 'hash' bs :: 'Skein_512_512'+-- in 'encode' h+-- @+--+-- where 'hash' is from "Crypto.Classes" (@crypto-api@ package),+-- 'encode' is from 'Serialize' (@cereal@ package) and @digest@+-- is a strict 'B.ByteString' with the hash. Given that we've+-- used 'Skein_512_512' which has an output size of 512 bits,+-- @digest@ will have @512 / 8 = 64@ bytes of length.++-- $skeinAsMAC+--+-- If you need a message authentication code (MAC), you may use+-- HMAC with Skein (e.g. HMAC-Skein-512-512). Using HMAC with+-- Skein is supported and secure. However, Skein also supports+-- another secure method, called Skein-MAC.+--+-- Skein-MAC is as secure as HMAC with Skein, however with a much+-- lower overhead (especially for short messages). HMAC requires+-- two hash invocations. Skein-MAC, on the other hand, requires+-- just one hash invocation after the setup.+--+-- To use Skein-MAC, you need 'skeinMAC' (or 'skeinMAC'') and+-- 'Serialize'. You also need a 'Key' with at least as many bits+-- as the state size you choose (@256@, @512@ or @1024@ bits).+--+-- Suppose you want to use Skein-MAC with 'Skein_512_512'. To+-- setup the MAC function with a 'Key' @key@ (that has at least+-- @512 / 8 = 64@ bytes), use+--+-- @+-- let calcMAC :: 'L.ByteString' -> 'Skein_512_512'+-- calcMAC = 'skeinMAC' key+-- @+--+-- It is recommended to partially apply 'skeinMAC' (or+-- 'skeinMAC'') to avoid recomputing the key setup. We give an+-- explicit type to 'calcMAC' because we have to choose which+-- Skein we want.+--+-- Now, if you want to calculate the Skein-MAC of a lazy+-- 'L.ByteString' message @msg@, use+--+-- @+-- let msgMAC = 'encode' (calcMAC msg)+-- @+--+-- where 'encode' is from 'Serialize' (@cereal@ package) and+-- @msgMAC@ is a strict 'B.ByteString' with the MAC.+--+-- Now, suppose you are given a @msg'@ with MAC @msgMAC'@ and+-- want to check the integrity and authenticity of @msg'@. You+-- may do so by calculating the MAC of @msg'@ and checking+-- against @msgMAC'@:+--+-- @+-- let msgMAC'' = 'encode' (calcMAC msg')+-- in if msgMAC' == msgMAC''+-- then Right \"Message is okay\"+-- else Left \"Message has been corrupted or tampered with\"+-- @++-- $about+--+-- From <http://www.skein-hash.info/about> at 09/2011:+--+-- Skein is a new family of cryptographic hash functions. Its+-- design combines speed, security, simplicity, and a great deal+-- of flexibility in a modular package that is easy to analyze.+--+-- Skein is fast. Skein-512 -- our primary proposal -- hashes data at+-- 6.1 clock cycles per byte on a 64-bit CPU. This means that on+-- a 3.1 GHz x64 Core 2 Duo CPU, Skein hashes data at 500+-- MBytes/second per core -- almost twice as fast as SHA-512 and+-- three times faster than SHA-256. An optional hash-tree mode+-- speeds up parallelizable implementations even more. Skein is+-- fast for short messages, too; Skein-512 hashes short messages+-- in about 1000 clock cycles.+--+-- Skein is secure. Our current best attack on Skein-512 is on 25+-- of 72 rounds, for a safety factor of 2.9. For comparison, at a+-- similar stage in the standardization process, the AES+-- encryption algorithm had an attack on 6 of 10 rounds, for a+-- safety factor of only 1.7. Additionally, Skein has a number of+-- provably secure properties, increasing confidence in the+-- algorithm.+--+-- Skein is simple. Using only three primitive operations, the+-- Skein compression function can be easily understood and+-- remembered. The rest of the algorithm is a straightforward+-- iteration of this function.+--+-- Skein is flexible. Skein is defined for three different+-- internal state sizes -- 256 bits, 512 bits, and 1024 bits --+-- and any output size. This allows Skein to be a drop-in+-- replacement for the entire SHA family of hash functions. A+-- completely optional and extendable argument system makes Skein+-- an efficient tool to use for a very large number of functions:+-- a PRNG, a stream cipher, a key derivation function,+-- authentication without the overhead of HMAC, and a+-- personalization capability. All these features can be+-- implemented with very low overhead. Together with the+-- Threefish large-block cipher at Skein core, this design+-- provides a full set of symmetric cryptographic primitives+-- suitable for most modern applications.+--+-- Skein is efficient on a variety of platforms, both hardware+-- and software. Skein-512 can be implemented in about 200 bytes+-- of state. Small devices, such as 8-bit smart cards, can+-- implement Skein-256 using about 100 bytes of memory. Larger+-- devices can implement the larger versions of Skein to achieve+-- faster speeds.+--+-- Skein was designed by a team of highly experienced+-- cryptographic experts from academia and industry, with+-- expertise in cryptography, security analysis, software, chip+-- design, and implementation of real-world cryptographic+-- systems. This breadth of knowledge allowed them to create a+-- balanced design that works well in all environments.++-- $mainHash+--+-- These are the main Skein hash functions. Unless you have any+-- special reasons, you should use one of these.+--+-- ['Skein_512_512'] is the primary cryptographic hash function+-- of this package. It can safely be used for all current+-- hashing applications, and should remain secure for the+-- foreseeable future.+--+-- ['Skein_1024_1024'] is the ultra-conservative variant. Even+-- if some future attack managed to break 'Skein_512_512', it+-- is quite likely that 'Skein_1024_1024' would remain secure.+--+-- ['Skein_256_256'] is the low-memory variant. It can be+-- implemented using 100 bytes of RAM, but this is not the case+-- with this implementation. It is faster than 'Skein_512_512'+-- only for small message lengths, so it's preferable to use+-- 'Skein_512_512'. If you can't afford 512 bits of output,+-- you may get the speed advantage of 'Skein_512_512' by using+-- 'Skein_512_256'.++-- $variants+--+-- These hash functions produce less output bits than their state+-- size. For example, 'Skein_512_160' produces 160 output bits+-- while having 512 bits of state size. Their main use is to be+-- a drop-in replacement to legacy hash functions. If you don't+-- have any special reason for using them, use one of the main+-- hash functions above (e.g. 'Skein_512_512').+--+-- You may replace:+--+-- [MD5] with 'Skein_256_128' or 'Skein_512_128'.+--+-- [SHA-1] with 'Skein_256_160' or 'Skein_512_160'.+--+-- [SHA-224] with 'Skein_256_224' or 'Skein_512_224'.+--+-- [SHA-256] with 'Skein_256_256' or 'Skein_512_256'.+--+-- [SHA-384] with 'Skein_512_384' or 'Skein_1024_384'.+--+-- [SHA-512] with 'Skein_512_512' or 'Skein_1024_512'.++----------------------------------------------------------------------++-- $skeinmac+--+-- The standard way to use a hash function for authentication is+-- to use the HMAC construction. While you may securely use+-- Skein with HMAC (e.g. HMAC-Skein-512-512), Skein also supports+-- another mode for MAC. Skein-MAC is as secure as+-- HMAC-Skein, however faster. Skein-MAC is as fast as+-- Skein as a hash function, with zero overhead.++-- | Secret key used to calculate the Skein-MAC.+--+-- The 'Key' may have any length. However, it's recommended to+-- have at least the same number of bits of the state size. For+-- example, when using 'skeinMAC' with 'Skein_512_256', it is+-- recommended to have a key with at least 64 bytes (512 bits),+-- which is the state size of 'Skein_512_256' (the first of the+-- two numbers).+type Key = B.ByteString++-- | Class of Skein contexts that may be used for Skein-MAC (all+-- of them). Included here mostly for documentation purposes,+-- since adding new instances is not safe (functions using+-- 'SkeinMAC' unsurprisingly assume that they are using Skein).+class SkeinMAC skeinCtx where+ -- | Construct a context @skeinCtx@ given a 'Key'. This+ -- context may be used with the usual 'Hash' interface to+ -- obtain a message authentication code (MAC).+ --+ -- For a simpler interface, see 'skeinMAC' and 'skeinMAC''.+ skeinMACCtx :: Key -> skeinCtx++-- | Calculate the Skein-MAC of a lazy 'L.ByteString' given a+-- 'Key'. You probably also want to apply 'encode' to get a+-- 'B.ByteString' out of the @digest@.+--+-- This function may be partially applied for increased+-- performance. Using a partially applied @skeinMAC@ is as fast+-- as using Skein as a cryptographic hash function. So, instead+-- of+--+-- @+-- let mac1 = skeinMAC key message1+-- mac2 = skeinMAC key message2+-- mac3 = skeinMAC key message3+-- ...+-- @+--+-- write the following code:+--+-- @+-- let calcMAC = skeinMAC key+-- mac1 = calcMAC message1+-- mac2 = calcMAC message2+-- mac3 = calcMAC message3+-- ...+-- @+--+-- This way the key will be processed only once (with+-- 'skeinMACCtx').+skeinMAC :: (SkeinMAC skeinCtx, Hash skeinCtx digest) =>+ Key -> L.ByteString -> digest+skeinMAC k = go+ where+ ctx = skeinMACCtx k+ go = go' ctx . L.toChunks+ go' ctx' [] = finalize ctx' B.empty+ go' ctx' [x] = finalize ctx' x+ go' ctx' (x:xs) = go' (updateCtx ctx' x) xs+ -- See the comment below on skeinMAC'.++-- | Same as 'skeinMAC', however using a strict 'B.ByteString'.+-- Should be faster for small 'B.ByteString'@s@.+skeinMAC' :: (SkeinMAC skeinCtx, Hash skeinCtx digest) =>+ Key -> B.ByteString -> digest+skeinMAC' k = go+ where+ ctx = skeinMACCtx k+ go = finalize ctx+ -- We can just call 'finalize' because of the way our+ -- implementation works. Basically, we accept ByteString+ -- of any length on both 'updateCtx' and 'finalize'.+ -- Calling just 'finalize' is more efficient.+++----------------------------------------------------------------------++-- | Helper function to create 'initialCtx'.+initialCtxSkein :: Storable internalCtx =>+ CSize+ -> (Ptr internalCtx -> CSize -> IO CInt)+ -> (internalCtx -> externalCtx)+ -> externalCtx+initialCtxSkein bits init_ mkCtx =+ unsafePerformIO $+ alloca $ \ctx_ptr -> do+ check $ init_ ctx_ptr bits+ fmap mkCtx $ peek ctx_ptr++-- | Helper function to create 'updateCtxSkein'.+updateCtxSkein :: Storable internalCtx =>+ (Ptr internalCtx -> Ptr Word8 -> CSize -> IO CInt)+ -> (externalCtx -> internalCtx)+ -> (internalCtx -> externalCtx)+ -> (externalCtx -> B.ByteString -> externalCtx)+updateCtxSkein update unCtx mkCtx = \ctx bs ->+ unsafePerformIO $+ BU.unsafeUseAsCStringLen bs $ \(bs_ptr, bs_len) ->+ with (unCtx ctx) $ \ctx_ptr -> do+ check $ update ctx_ptr (castPtr bs_ptr) (fromIntegral bs_len)+ fmap mkCtx $ peek ctx_ptr++-- | Helper function to create 'finalize'.+finalizeSkein :: Storable internalCtx =>+ Int+ -> (Ptr internalCtx -> Ptr Word8 -> CSize -> IO CInt)+ -> (Ptr internalCtx -> Ptr Word8 -> IO CInt)+ -> (externalCtx -> internalCtx)+ -> (B.ByteString -> hash)+ -> (externalCtx -> B.ByteString -> hash)+finalizeSkein hashLenBytes update final unCtx mkHash = \ctx bs ->+ unsafePerformIO $+ with (unCtx ctx) $ \ctx_ptr -> do+ unless (B.null bs) $+ BU.unsafeUseAsCStringLen bs $ \(bs_ptr, bs_len) ->+ check $ update ctx_ptr (castPtr bs_ptr) (fromIntegral bs_len)+ fmap mkHash $ BI.create hashLenBytes $ check . final ctx_ptr . castPtr++-- | Helper function to create 'skeinMACCtx'.+skeinMACCtxSkein :: Storable internalCtx =>+ CSize+ -> (Ptr internalCtx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt)+ -> (internalCtx -> externalCtx)+ -> (Key -> externalCtx)+skeinMACCtxSkein bits initExt mkCtx = \key ->+ unsafePerformIO $+ BU.unsafeUseAsCStringLen key $ \(key_ptr, key_len) ->+ alloca $ \ctx_ptr -> do+ check $ initExt ctx_ptr bits sKEIN_SEQUENTIAL (castPtr key_ptr) (fromIntegral key_len)+ fmap mkCtx $ peek ctx_ptr++++----------------------------------------------------------------------+-- Skein-256+----------------------------------------------------------------------++-- | Context of the Skein-256-128 hash function.+newtype Skein_256_128_Ctx = S_256_128_Ctx {unS_256_128_Ctx :: Skein256Ctx}++-- | Skein-256-128 hash. You probably want to use 'encode' to+-- obtain a 128-bit (16-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for MD5.+newtype Skein_256_128 = S_256_128 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_256_128 where+ put (S_256_128 bs) = putByteString bs+ get = fmap S_256_128 $ getByteString 16++instance Hash Skein_256_128_Ctx Skein_256_128 where+ outputLength = Tagged 128+ blockLength = Tagged 256+ initialCtx = initialCtxSkein 128 skein256Init S_256_128_Ctx+ updateCtx = updateCtxSkein skein256Update unS_256_128_Ctx S_256_128_Ctx+ finalize = finalizeSkein 16 skein256Update skein256Final unS_256_128_Ctx S_256_128++instance SkeinMAC Skein_256_128_Ctx where+ skeinMACCtx = skeinMACCtxSkein 128 skein256InitExt S_256_128_Ctx+++-- | Context of the Skein-256-160 hash function.+newtype Skein_256_160_Ctx = S_256_160_Ctx {unS_256_160_Ctx :: Skein256Ctx}++-- | Skein-256-160 hash. You probably want to use 'encode' to+-- obtain a 160-bit (20-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-1.+newtype Skein_256_160 = S_256_160 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_256_160 where+ put (S_256_160 bs) = putByteString bs+ get = fmap S_256_160 $ getByteString 20++instance Hash Skein_256_160_Ctx Skein_256_160 where+ outputLength = Tagged 160+ blockLength = Tagged 256+ initialCtx = initialCtxSkein 160 skein256Init S_256_160_Ctx+ updateCtx = updateCtxSkein skein256Update unS_256_160_Ctx S_256_160_Ctx+ finalize = finalizeSkein 20 skein256Update skein256Final unS_256_160_Ctx S_256_160++instance SkeinMAC Skein_256_160_Ctx where+ skeinMACCtx = skeinMACCtxSkein 160 skein256InitExt S_256_160_Ctx+++-- | Context of the Skein-256-224 hash function.+newtype Skein_256_224_Ctx = S_256_224_Ctx {unS_256_224_Ctx :: Skein256Ctx}++-- | Skein-256-224 hash. You probably want to use 'encode' to+-- obtain a 224-bit (28-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-224.+newtype Skein_256_224 = S_256_224 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_256_224 where+ put (S_256_224 bs) = putByteString bs+ get = fmap S_256_224 $ getByteString 28++instance Hash Skein_256_224_Ctx Skein_256_224 where+ outputLength = Tagged 224+ blockLength = Tagged 256+ initialCtx = initialCtxSkein 224 skein256Init S_256_224_Ctx+ updateCtx = updateCtxSkein skein256Update unS_256_224_Ctx S_256_224_Ctx+ finalize = finalizeSkein 28 skein256Update skein256Final unS_256_224_Ctx S_256_224++instance SkeinMAC Skein_256_224_Ctx where+ skeinMACCtx = skeinMACCtxSkein 224 skein256InitExt S_256_224_Ctx+++-- | Context of the Skein-256-256 hash function.+newtype Skein_256_256_Ctx = S_256_256_Ctx {unS_256_256_Ctx :: Skein256Ctx}++-- | Skein-256-256 hash. You probably want to use 'encode' to+-- obtain a 256-bit (32-byte) 'B.ByteString'. Usually it's better+-- to use 'Skein_512_256' (256 bits of output) or 'Skein_512_512'+-- (512 bits of output).+newtype Skein_256_256 = S_256_256 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_256_256 where+ put (S_256_256 bs) = putByteString bs+ get = fmap S_256_256 $ getByteString 32++instance Hash Skein_256_256_Ctx Skein_256_256 where+ outputLength = Tagged 256+ blockLength = Tagged 256+ initialCtx = initialCtxSkein 256 skein256Init S_256_256_Ctx+ updateCtx = updateCtxSkein skein256Update unS_256_256_Ctx S_256_256_Ctx+ finalize = finalizeSkein 32 skein256Update skein256Final unS_256_256_Ctx S_256_256++instance SkeinMAC Skein_256_256_Ctx where+ skeinMACCtx = skeinMACCtxSkein 256 skein256InitExt S_256_256_Ctx+++++----------------------------------------------------------------------+-- Skein-512+----------------------------------------------------------------------++-- | Context of the Skein-512-128 hash function.+newtype Skein_512_128_Ctx = S_512_128_Ctx {unS_512_128_Ctx :: Skein512Ctx}++-- | Skein-512-128 hash. You probably want to use 'encode' to+-- obtain a 128-bit (16-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for MD5.+newtype Skein_512_128 = S_512_128 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_128 where+ put (S_512_128 bs) = putByteString bs+ get = fmap S_512_128 $ getByteString 16++instance Hash Skein_512_128_Ctx Skein_512_128 where+ outputLength = Tagged 128+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 128 skein512Init S_512_128_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_128_Ctx S_512_128_Ctx+ finalize = finalizeSkein 16 skein512Update skein512Final unS_512_128_Ctx S_512_128++instance SkeinMAC Skein_512_128_Ctx where+ skeinMACCtx = skeinMACCtxSkein 128 skein512InitExt S_512_128_Ctx++-- | Context of the Skein-512-160 hash function.+newtype Skein_512_160_Ctx = S_512_160_Ctx {unS_512_160_Ctx :: Skein512Ctx}++-- | Skein-512-160 hash. You probably want to use 'encode' to+-- obtain a 160-bit (20-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-1.+newtype Skein_512_160 = S_512_160 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_160 where+ put (S_512_160 bs) = putByteString bs+ get = fmap S_512_160 $ getByteString 20++instance Hash Skein_512_160_Ctx Skein_512_160 where+ outputLength = Tagged 160+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 160 skein512Init S_512_160_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_160_Ctx S_512_160_Ctx+ finalize = finalizeSkein 20 skein512Update skein512Final unS_512_160_Ctx S_512_160++instance SkeinMAC Skein_512_160_Ctx where+ skeinMACCtx = skeinMACCtxSkein 160 skein512InitExt S_512_160_Ctx+++-- | Context of the Skein-512-224 hash function.+newtype Skein_512_224_Ctx = S_512_224_Ctx {unS_512_224_Ctx :: Skein512Ctx}++-- | Skein-512-224 hash. You probably want to use 'encode' to+-- obtain a 224-bit (28-byte) 'B.ByteString'. May be used as a drop-in replacement for SHA-224.+newtype Skein_512_224 = S_512_224 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_224 where+ put (S_512_224 bs) = putByteString bs+ get = fmap S_512_224 $ getByteString 28++instance Hash Skein_512_224_Ctx Skein_512_224 where+ outputLength = Tagged 224+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 224 skein512Init S_512_224_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_224_Ctx S_512_224_Ctx+ finalize = finalizeSkein 28 skein512Update skein512Final unS_512_224_Ctx S_512_224++instance SkeinMAC Skein_512_224_Ctx where+ skeinMACCtx = skeinMACCtxSkein 224 skein512InitExt S_512_224_Ctx+++-- | Context of the Skein-512-256 hash function.+newtype Skein_512_256_Ctx = S_512_256_Ctx {unS_512_256_Ctx :: Skein512Ctx}++-- | Skein-512-256 hash. You probably want to use 'encode' to+-- obtain a 256-bit (32-byte) 'B.ByteString'.+newtype Skein_512_256 = S_512_256 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_256 where+ put (S_512_256 bs) = putByteString bs+ get = fmap S_512_256 $ getByteString 32++instance Hash Skein_512_256_Ctx Skein_512_256 where+ outputLength = Tagged 256+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 256 skein512Init S_512_256_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_256_Ctx S_512_256_Ctx+ finalize = finalizeSkein 32 skein512Update skein512Final unS_512_256_Ctx S_512_256++instance SkeinMAC Skein_512_256_Ctx where+ skeinMACCtx = skeinMACCtxSkein 256 skein512InitExt S_512_256_Ctx+++-- | Context of the Skein-512-384 hash function.+newtype Skein_512_384_Ctx = S_512_384_Ctx {unS_512_384_Ctx :: Skein512Ctx}++-- | Skein-512-384 hash. You probably want to use 'encode' to+-- obtain a 384-bit (48-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-384.+newtype Skein_512_384 = S_512_384 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_384 where+ put (S_512_384 bs) = putByteString bs+ get = fmap S_512_384 $ getByteString 48++instance Hash Skein_512_384_Ctx Skein_512_384 where+ outputLength = Tagged 384+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 384 skein512Init S_512_384_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_384_Ctx S_512_384_Ctx+ finalize = finalizeSkein 48 skein512Update skein512Final unS_512_384_Ctx S_512_384++instance SkeinMAC Skein_512_384_Ctx where+ skeinMACCtx = skeinMACCtxSkein 384 skein512InitExt S_512_384_Ctx+++-- | Context of the Skein-512-512 hash function.+newtype Skein_512_512_Ctx = S_512_512_Ctx {unS_512_512_Ctx :: Skein512Ctx}++-- | Skein-512-512 hash. You probably want to use 'encode' to+-- obtain a 512-bit (64-byte) 'B.ByteString'. It's the main Skein+-- hash function. May be used as a drop-in replacement for+-- SHA-512 as well.+newtype Skein_512_512 = S_512_512 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_512_512 where+ put (S_512_512 bs) = putByteString bs+ get = fmap S_512_512 $ getByteString 64++instance Hash Skein_512_512_Ctx Skein_512_512 where+ outputLength = Tagged 512+ blockLength = Tagged 512+ initialCtx = initialCtxSkein 512 skein512Init S_512_512_Ctx+ updateCtx = updateCtxSkein skein512Update unS_512_512_Ctx S_512_512_Ctx+ finalize = finalizeSkein 64 skein512Update skein512Final unS_512_512_Ctx S_512_512++instance SkeinMAC Skein_512_512_Ctx where+ skeinMACCtx = skeinMACCtxSkein 512 skein512InitExt S_512_512_Ctx++++----------------------------------------------------------------------+-- Skein-1024+----------------------------------------------------------------------++-- | Context of the Skein-1024-384 hash function.+newtype Skein_1024_384_Ctx = S_1024_384_Ctx {unS_1024_384_Ctx :: Skein1024Ctx}++-- | Skein-1024-384 hash. You probably want to use 'encode' to+-- obtain a 384-bit (48-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-384.+newtype Skein_1024_384 = S_1024_384 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_1024_384 where+ put (S_1024_384 bs) = putByteString bs+ get = fmap S_1024_384 $ getByteString 48++instance Hash Skein_1024_384_Ctx Skein_1024_384 where+ outputLength = Tagged 384+ blockLength = Tagged 1024+ initialCtx = initialCtxSkein 384 skein1024Init S_1024_384_Ctx+ updateCtx = updateCtxSkein skein1024Update unS_1024_384_Ctx S_1024_384_Ctx+ finalize = finalizeSkein 48 skein1024Update skein1024Final unS_1024_384_Ctx S_1024_384++instance SkeinMAC Skein_1024_384_Ctx where+ skeinMACCtx = skeinMACCtxSkein 384 skein1024InitExt S_1024_384_Ctx+++-- | Context of the Skein-1024-512 hash function.+newtype Skein_1024_512_Ctx = S_1024_512_Ctx {unS_1024_512_Ctx :: Skein1024Ctx}++-- | Skein-1024-512 hash. You probably want to use 'encode' to+-- obtain a 512-bit (64-byte) 'B.ByteString'. May be used as a+-- drop-in replacement for SHA-512.+newtype Skein_1024_512 = S_1024_512 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_1024_512 where+ put (S_1024_512 bs) = putByteString bs+ get = fmap S_1024_512 $ getByteString 64++instance Hash Skein_1024_512_Ctx Skein_1024_512 where+ outputLength = Tagged 512+ blockLength = Tagged 1024+ initialCtx = initialCtxSkein 512 skein1024Init S_1024_512_Ctx+ updateCtx = updateCtxSkein skein1024Update unS_1024_512_Ctx S_1024_512_Ctx+ finalize = finalizeSkein 64 skein1024Update skein1024Final unS_1024_512_Ctx S_1024_512++instance SkeinMAC Skein_1024_512_Ctx where+ skeinMACCtx = skeinMACCtxSkein 512 skein1024InitExt S_1024_512_Ctx+++-- | Context of the Skein-1024-1024 hash function.+newtype Skein_1024_1024_Ctx = S_1024_1024_Ctx {unS_1024_1024_Ctx :: Skein1024Ctx}++-- | Skein-1024-1024 hash. You probably want to use 'encode' to+-- obtain a 1024-bit (128-byte) 'B.ByteString'. This is the+-- ultra-conservative variant. Even if some future attack+-- managed to break Skein-512, it's quite likely that Skein-1024+-- would remain secure.+newtype Skein_1024_1024 = S_1024_1024 B.ByteString deriving (Eq, Ord)++instance Serialize Skein_1024_1024 where+ put (S_1024_1024 bs) = putByteString bs+ get = fmap S_1024_1024 $ getByteString 128++instance Hash Skein_1024_1024_Ctx Skein_1024_1024 where+ outputLength = Tagged 1024+ blockLength = Tagged 1024+ initialCtx = initialCtxSkein 1024 skein1024Init S_1024_1024_Ctx+ updateCtx = updateCtxSkein skein1024Update unS_1024_1024_Ctx S_1024_1024_Ctx+ finalize = finalizeSkein 128 skein1024Update skein1024Final unS_1024_1024_Ctx S_1024_1024++instance SkeinMAC Skein_1024_1024_Ctx where+ skeinMACCtx = skeinMACCtxSkein 1024 skein1024InitExt S_1024_1024_Ctx
+ src/Crypto/Skein/Internal.hsc view
@@ -0,0 +1,154 @@+{-# CFILES+ c_impl/reference/skein.c+ c_impl/reference/skein_block.c+ #-}++-----------------------------------------------------------------------------+-- |+-- Module : Crypto.Skein.Internal+-- Copyright : (c) 2011 Felipe A. Lessa+-- License : BSD3 (see LICENSE)+--+-- Maintainer : felipe.lessa@gmail.com+-- Stability : provisional+-- Portability : portable (needs FFI)+--+-- Basic wrappers around the C library. You shouldn't need to+-- use these functions. Instead, use the high-level+-- "Crypto.Skein" module.+--+-----------------------------------------------------------------------------++module Crypto.Skein.Internal+ ( -- * Return codes+ sKEIN_SUCCESS+ , sKEIN_FAIL+ , sKEIN_BAD_HASHLEN+ , check++ -- * Skein-256+ , Skein256Ctx(..)+ , skein256Init+ , skein256Update+ , skein256Final+ , skein256InitExt+ , skein256FinalPad+ , skein256Output++ -- * Skein-512+ , Skein512Ctx(..)+ , skein512Init+ , skein512Update+ , skein512Final+ , skein512InitExt+ , skein512FinalPad+ , skein512Output++ -- * Skein-1024+ , Skein1024Ctx(..)+ , skein1024Init+ , skein1024Update+ , skein1024Final+ , skein1024InitExt+ , skein1024FinalPad+ , skein1024Output++ -- * Misc constants+ , sKEIN_SEQUENTIAL+ ) where++-- from base+import Foreign+import Foreign.C++-- from bytestring+import qualified Data.ByteString as B+import qualified Data.ByteString.Internal as BI+import qualified Data.ByteString.Unsafe as BU++-- from this package+#include "skein.h"++sKEIN_SUCCESS, sKEIN_FAIL, sKEIN_BAD_HASHLEN :: CInt+sKEIN_SUCCESS = #{const SKEIN_SUCCESS}+sKEIN_FAIL = #{const SKEIN_FAIL}+sKEIN_BAD_HASHLEN = #{const SKEIN_BAD_HASHLEN}++-- | Throws exception if the function does not return+-- successfully.+check :: IO CInt -> IO ()+check act = do+ x <- act+ case () of+ () | x == sKEIN_SUCCESS -> return ()+ | x == sKEIN_FAIL -> fail "Skein returned FAIL."+ | x == sKEIN_BAD_HASHLEN -> fail "Skein returned BAD_HASHLEN."+ | otherwise -> fail "Skein returned unknown code."++newtype Skein256Ctx = S256Ctx {unS256Ctx :: B.ByteString}+newtype Skein512Ctx = S512Ctx {unS512Ctx :: B.ByteString}+newtype Skein1024Ctx = S1024Ctx {unS1024Ctx :: B.ByteString}++size256Ctx, size512Ctx, size1024Ctx :: Int+size256Ctx = #{size Skein_256_Ctxt_t}+size512Ctx = #{size Skein_512_Ctxt_t}+size1024Ctx = #{size Skein1024_Ctxt_t}++instance Storable Skein256Ctx where+ sizeOf _ = size256Ctx+ alignment _ = 16+ peek ptr =+ fmap S256Ctx $ BI.create size256Ctx $ \bptr ->+ BI.memcpy bptr (castPtr ptr) (fromIntegral size256Ctx)+ poke ptr (S256Ctx bs) =+ BU.unsafeUseAsCString bs $ \bs_ptr ->+ BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size256Ctx)++instance Storable Skein512Ctx where+ sizeOf _ = size512Ctx+ alignment _ = 16+ peek ptr =+ fmap S512Ctx $ BI.create size512Ctx $ \bptr ->+ BI.memcpy bptr (castPtr ptr) (fromIntegral size512Ctx)+ poke ptr (S512Ctx bs) =+ BU.unsafeUseAsCString bs $ \bs_ptr ->+ BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size512Ctx)++instance Storable Skein1024Ctx where+ sizeOf _ = size1024Ctx+ alignment _ = 16+ peek ptr =+ fmap S1024Ctx $ BI.create size1024Ctx $ \bptr ->+ BI.memcpy bptr (castPtr ptr) (fromIntegral size1024Ctx)+ poke ptr (S1024Ctx bs) =+ BU.unsafeUseAsCString bs $ \bs_ptr ->+ BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size1024Ctx)++foreign import ccall unsafe "skein.h Skein_256_Init" skein256Init :: Ptr Skein256Ctx -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_Init" skein512Init :: Ptr Skein512Ctx -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_Init" skein1024Init :: Ptr Skein1024Ctx -> CSize -> IO CInt++foreign import ccall unsafe "skein.h Skein_256_Update" skein256Update :: Ptr Skein256Ctx -> Ptr Word8 -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_Update" skein512Update :: Ptr Skein512Ctx -> Ptr Word8 -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_Update" skein1024Update :: Ptr Skein1024Ctx -> Ptr Word8 -> CSize -> IO CInt++foreign import ccall unsafe "skein.h Skein_256_Final" skein256Final :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_Final" skein512Final :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_Final" skein1024Final :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt++foreign import ccall unsafe "skein.h Skein_256_InitExt " skein256InitExt :: Ptr Skein256Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_InitExt " skein512InitExt :: Ptr Skein512Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_InitExt " skein1024InitExt :: Ptr Skein1024Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt++foreign import ccall unsafe "skein.h Skein_256_Final_Pad" skein256FinalPad :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_Final_Pad" skein512FinalPad :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_Final_Pad" skein1024FinalPad :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt++foreign import ccall unsafe "skein.h Skein_256_Output" skein256Output :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein_512_Output" skein512Output :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt+foreign import ccall unsafe "skein.h Skein1024_Output" skein1024Output :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt+++-- | Pass to @InitExt@ to get sequential processing.+sKEIN_SEQUENTIAL :: Word64+sKEIN_SEQUENTIAL = 0
+ tests/runtests.hs view
@@ -0,0 +1,174 @@+-- from base+import Control.Applicative ((<$>))+import Control.Monad (forM_, unless)+import Data.Char (isNumber)+import Data.Maybe (catMaybes)+import Text.Printf++-- from bytestring+import qualified Data.ByteString as B+--import qualified Data.ByteString.Lazy as L++-- from cereal+import Data.Serialize (encode)++-- from tagged+import Data.Tagged (Tagged(..))++-- from crypto-api+import Crypto.Classes+++-- from filepath+import System.FilePath ((</>))++-- from transformers+import Control.Monad.Trans.Writer.Lazy (Writer)++-- from hspec+import Test.Hspec.Monadic+--import Test.Hspec.QuickCheck+import Test.Hspec.HUnit ()+++-- from this package+import Paths_skein (getDataFileName)+import Crypto.Skein+++++main :: IO ()+main = do+ skein_golden_kat_txt <- getDataFileName ("tests" </> "skein_golden_kat.txt")+ kats <- parseKats <$> readFile skein_golden_kat_txt+ putStrLn $ "Parsed " ++ show (length kats) ++ " known answer tests"+ hspecX $ do+ describe "Skein golden known answer tests" $ do+ skeinKats kats (undefined :: Skein_512_512)+ skeinKats kats (undefined :: Skein_1024_1024)+ skeinKats kats (undefined :: Skein_256_256)+ skeinKats kats (undefined :: Skein_256_128)+ skeinKats kats (undefined :: Skein_256_160)+ skeinKats kats (undefined :: Skein_256_224)+ skeinKats kats (undefined :: Skein_512_128)+ skeinKats kats (undefined :: Skein_512_160)+ skeinKats kats (undefined :: Skein_512_224)+ skeinKats kats (undefined :: Skein_512_256)+ skeinKats kats (undefined :: Skein_512_384)+ skeinKats kats (undefined :: Skein_1024_384)+ skeinKats kats (undefined :: Skein_1024_512)++readMsg :: Read a => String -> String -> a+readMsg msg str = case readsPrec 0 str of+ [(r, "")] -> r+ _ -> error msg++----------------------------------------------------------------------++data Kat = Kat { skeinType :: SkeinType+ , message :: B.ByteString+ , macKey :: Maybe B.ByteString+ , result :: B.ByteString+ }++data SkeinType = Skein !Int !Int deriving (Eq)++instance Show SkeinType where+ show (Skein s o) = printf "Skein-%d-%d" s o++parseKats :: String -> [Kat]+parseKats = catMaybes . map parseKat . groupKats . lines . filter (/= '\r')++groupKats :: [String] -> [[String]]+groupKats = go []+ where+ sep = "--------------------------------"+ go acc (x:xs) | x == sep = reverse acc : go [] xs+ | otherwise = go (x:acc) xs+ go [] [] = []+ go (_:_) [] = error "groupKats: didn't find last separator"++parseKat :: [String] -> Maybe Kat+parseKat ("":xs) = parseKat xs+parseKat (header:"":rest) =+ case (isTree header, parseMsgLen header, parseBlocks rest) of+ (_, msgLen, _) | msgLen `mod` 8 /= 0 -> Nothing+ (False, _, [Message msg, Result ret]) -> kat msg Nothing ret+ (False, _, [Message msg, MACKey mac, Result ret]) -> kat msg (Just mac) ret+ _ -> Nothing+ where kat msg mac ret = Just $ Kat (parseSkeinType header) msg mac ret+parseKat _ = Nothing++isTree :: String -> Bool+isTree ('T':'r':'e':'e':':':_) = True+isTree (_:xs) = isTree xs+isTree [] = False++parseMsgLen :: String -> Int+parseMsgLen ('m':'s':'g':'L':'e':'n':' ':'=':xs) = readMsg "parseMsgLen" $ take 6 xs+parseMsgLen (_:xs) = parseMsgLen xs+parseMsgLen [] = error "parseMsgLen: didn't find msgLen"++parseSkeinType :: String -> SkeinType+parseSkeinType xs0 =+ let (":Skein", '-':xs1) = break (== '-') xs0+ (stateS, xs2) = span isNumber xs1+ (':':_, xs3) = break isNumber xs2+ (outputS, _) = span isNumber xs3+ in Skein (readMsg "stateS" stateS) (readMsg "outputS" outputS)++data Block = Message B.ByteString | MACKey B.ByteString | Result B.ByteString++block :: String -> B.ByteString -> Block+block "Message data:" = Message+block "Result:" = Result+block ('M':'A':'C':_) = MACKey+block x = error $ "block: unknown block type " ++ x++parseBlocks :: [String] -> [Block]+parseBlocks [] = []+parseBlocks (header:rest)+ | last header /= ':' = error "parseBlocks: something went wrong"+ | otherwise = let (data_, rest') = span ((== ' ') . head) rest+ in block header (parseData data_) : parseBlocks rest'++parseData :: [String] -> B.ByteString+parseData [' ':' ':' ':' ':'(':'n':'o':'n':'e':')':_] = B.empty+parseData xs = B.pack $ map (readMsg "parseData" . ("0x"++)) $ concatMap words xs++----------------------------------------------------------------------++skeinKats :: (SkeinMAC skeinCtx, Hash skeinCtx digest) =>+ [Kat] -> digest -> Writer [ItSpec] ()+skeinKats kats digest =+ let get t@(Tagged x) = x+ where+ f :: Tagged d a -> d+ f = undefined++ p = f t `asTypeOf` digest+ skeinType = Skein (get blockLength) (get outputLength)+ myHashKats = [(msg, ret) | Kat t msg Nothing ret <- kats, t == skeinType]+ myMacKats = [(msg, macKey, ret) | Kat t msg (Just macKey) ret <- kats, t == skeinType]+ lenHashKats = length myHashKats+ lenMacKats = length myMacKats+ testName =+ if lenHashKats + lenMacKats == 0+ then printf "has no tests for %s =(" (show skeinType)+ else printf "works for %s (%d hash tests, %d MAC tests)"+ (show skeinType) lenHashKats lenMacKats+ in it testName $ do+ putStrLn "Testing hashes..."+ forM_ myHashKats $ \(msg, ret) -> do+ let myHash = hash' msg `asTypeOf` digest+ unless (encode myHash == ret) $ fail $ concat ["Message: ", show msg,+ "\nExpected: ", show ret,+ "\nCalculated: ", show (encode myHash)]+ putStrLn "Testing MACs..."+ forM_ myMacKats $ \(msg, macKey, ret) -> do+ let myMAC = skeinMAC' macKey msg `asTypeOf` digest+ unless (encode myMAC == ret) $ fail $ concat ["Message: ", show msg,+ "MAC Key: ", show macKey,+ "\nExpected: ", show ret,+ "\nCalculated: ", show (encode myMAC)]
+ tests/skein_golden_kat.txt view
@@ -0,0 +1,9542 @@+ +:Skein-256: 256-bit hash, msgLen = 0 bits, data = 'zero' + +Message data: + (none) +Result: + BC 27 63 F7 07 E2 62 B8 0E 03 13 79 15 43 A7 AB + 0A 4B 6C D0 83 27 0A FB 2F CE 42 72 E1 BB 0A A9 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1 bits, data = 'zero' + +Message data: + 00 +Result: + ED 77 C7 E7 4F BB 73 65 BB AC 9D 7D 47 08 C6 58 + DE A3 78 BD 71 EF 3A C8 B5 BA F1 A5 62 5E B0 6A +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2 bits, data = 'zero' + +Message data: + 00 +Result: + FC AA 4F 9D 9B 8A 3C 39 50 6C 2E 7D 5D 55 81 13 + 11 77 09 54 AD 1E 03 AB DB BE CE 82 0E 4F 6A B3 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 3 bits, data = 'zero' + +Message data: + 00 +Result: + A6 49 21 E7 93 77 70 80 3C 9B C2 58 F6 40 0E 23 + A1 7C DF C5 F9 F6 6C 2A C4 5B 08 AF 70 DA 62 D6 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4 bits, data = 'zero' + +Message data: + 00 +Result: + 82 CA 87 01 9A FB 9A 26 12 27 43 18 1C AC 3E BD + 46 1E E4 B4 CF D5 5C 99 BF A5 F9 7E FD 01 8F 13 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 5 bits, data = 'zero' + +Message data: + 00 +Result: + 1F 58 41 F1 4F 91 CC 9E 9E FF 56 C6 EF E4 F9 48 + 25 E4 75 B7 4E 35 92 6B 4B 21 4B 46 F5 2E A4 70 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 6 bits, data = 'zero' + +Message data: + 00 +Result: + 65 BC A8 F0 87 1A EB 4F B1 8D 19 10 A9 FD 44 C4 + B0 7F 55 C1 85 A7 C1 AB 14 17 28 06 F8 58 09 9D +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 7 bits, data = 'zero' + +Message data: + 00 +Result: + F8 87 DF 7E 28 06 49 2C 1D F7 EA E3 07 15 89 C2 + 96 E9 20 09 DE EC CD 93 73 A9 44 D0 5D A8 4F 47 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 8 bits, data = 'zero' + +Message data: + 00 +Result: + A6 CA BF 2D B0 1A 6F 27 42 40 42 93 64 39 92 8C + A8 38 54 93 52 94 DF 98 19 E7 C4 C6 61 FC 31 9F +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 9 bits, data = 'zero' + +Message data: + 00 00 +Result: + 0E 63 10 8F BA 66 07 AB A1 8A 27 B1 E1 EB 91 11 + 52 00 2B 0A 19 EF 09 82 35 EC A3 BB AA CE E0 F4 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 10 bits, data = 'zero' + +Message data: + 00 00 +Result: + 60 4C 33 69 A8 83 18 81 39 5F B5 87 5F F8 74 80 + A9 C8 64 91 7F 5F EA EB EC 29 F9 79 92 C6 E0 37 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 32 bits, data = 'zero' + +Message data: + 00 00 00 00 +Result: + A8 17 45 A0 D1 5D 10 32 4A 44 50 69 41 23 ED 63 + 2A E3 6A 69 30 8B 85 12 F5 6E A5 3C 4B 74 D1 18 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 64 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 +Result: + 70 03 5E DF 23 5A 44 9C 43 36 B8 22 2D F8 89 FB + 01 7C FA 70 35 77 0D 0F D9 8F 67 87 AC C9 7B 6C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 128 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + F6 C8 39 70 CF 27 D7 C1 C6 FB A8 8B D8 DB DC 6E + 73 9E EC 4F 74 54 AE F0 68 3A C5 2A 2A E2 8D 4E +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 192 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 +Result: + 5A CE BD 60 D8 8C 56 EF 3E 22 4A 53 5E B1 B8 83 + 14 CC A8 55 F4 AE 11 4A 71 33 86 49 FA 1C 23 BD +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 255 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + D2 89 0C 65 27 2C 40 5A FB E7 34 2B DE 05 53 E1 + 8C FA 77 35 2B 11 83 7A B5 58 15 F6 E9 92 69 BE +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 256 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + BD 26 91 B6 8F 9B E3 3E 60 89 DA 56 0D 7C 51 9D + C2 44 53 3D A7 1E 7B 3B 11 E2 94 A1 5E 6A 6C 30 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 257 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + C9 9A AB 35 9D 10 DA AF F7 9E 11 52 99 D7 60 E1 + 5F AA 61 CE 7D 5B AF C4 B9 99 AF FB 3D 13 D8 36 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 384 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 4E 0E 2E 06 C1 DC AF B5 93 EA 0E 38 DF 44 E2 E0 + 8F 14 05 A4 C8 3B B7 E3 60 B0 97 15 DA 9D 33 B0 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 511 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 1A F7 DD 1A E1 DF 4E 68 D4 5F 2C 60 18 70 E5 F7 + 5C 93 82 88 9C 06 E4 72 D3 1C FE 28 44 29 6E 03 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 512 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + B7 CC 86 69 7D C3 72 0C B6 D0 38 06 77 0B 38 86 + 5C 5F 9C FE 5A 27 FD D3 F9 A7 E6 D4 E0 A4 35 8B +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 513 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 8E BF 0F 06 29 C4 67 AA 3A 9D 7D 89 60 0E 92 EF + 08 98 65 9A B2 EA 60 1B 7A 3E 13 7C 4C FA 27 57 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 768 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 06 F8 74 86 64 2A F0 93 41 A1 A8 19 06 E0 8E 6A + 40 7C 5A 50 14 F1 21 61 94 22 6F D4 E9 29 9D D7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 13 FF FB E9 31 E6 FC 8F 4F 07 71 83 6C 41 A9 EA + D4 C2 09 2C 4A 78 51 A9 D0 2A FC EF AB 7B 86 4F +-------------------------------- + +:Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 96 D9 9C 55 B6 A3 D0 42 7D 58 69 6D CA B3 1F 66 + 70 57 10 D6 +-------------------------------- + +:Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 60 9B BF 25 B7 E7 E9 33 64 AE F8 62 6C 84 04 CE + 77 C9 81 38 C6 F9 41 DB 6D 88 58 B8 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + DB 65 89 5E B2 11 FB 9C E3 B6 0B 02 30 C2 FD A1 + EF BA 3B 6E DC 23 E9 27 C6 0B 24 74 1E 42 39 C9 +-------------------------------- + +:Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 4C 80 1D 71 97 AD ED 15 EF A2 35 F0 F5 A8 F2 62 + 1D 92 07 37 89 13 E9 BF CF 11 BE 62 09 17 DD F7 + C9 68 90 B1 85 7F 57 C0 C4 C5 B6 52 F7 EF BB 9E +-------------------------------- + +:Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + E2 1E 36 5F F8 29 C6 0D AF F5 0C 17 4B 81 B3 C1 + F2 2A 58 6E 9F 4C D0 E4 F3 BA 95 5A 89 3D FD 60 + 56 74 7A 70 21 F9 28 D7 D5 F9 FF 45 C1 8F B5 48 + C7 C7 66 A5 9D 1D 60 A8 99 1E EB E9 6E 38 1F 19 +-------------------------------- + +:Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 30 ED 8E B8 AD 70 2E 1A 81 8B FB C8 4E DE 51 6B + B5 37 79 4A 5D 80 85 C4 B7 66 FE C5 1E C3 E0 B4 + 56 E1 7D BC 7F 59 D3 A6 51 2B 51 C8 BC A1 26 5C + 0A EE 47 28 FB 3B A0 C7 9F 70 30 43 0C E3 55 55 + 7C 5A 2C FF 0F AC 58 6B 1F 08 25 D4 FE 7C 9C 8A + 43 69 EB 8C DD 4B B4 29 42 A6 3C D4 28 6B 42 D6 + EF 08 0A 4B FA 27 F1 BA 0B 04 2D 93 06 6C FA 20 + F6 C7 96 32 EB 31 64 59 A6 55 B1 5B 51 BC 29 CE +-------------------------------- + +:Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 88 C9 53 4E F7 4B 3A 5B 37 59 AD BB 32 9B 44 25 + 93 5B 7B 0D 3B 7A 43 FA E8 69 17 4D EF 74 D6 FE + 64 +-------------------------------- + +:Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 6A 91 B4 96 DA 81 23 49 5A FB 41 BF D1 2A 0A 56 + BC 67 0C A8 64 51 93 1C 81 CC F3 04 A8 8D 7F 5A + 4C D6 84 EF 65 8C FE D0 8B A7 8D 97 CB D3 B3 22 + 57 7B F1 4D 8D D5 3D 22 B9 02 01 42 90 5B 5B 6A + 7C +-------------------------------- + +:Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 78 DF 19 A1 3D 24 33 12 C8 D0 28 79 9A EF 14 F7 + 86 F3 20 30 4D 53 F7 98 1F AE 2B 37 4D ED 3B C6 + 8D 41 0B 0F AA 0D C5 70 7F 9C CE 9A 9C 11 F6 76 + 75 C7 4E 60 28 51 A1 4A EC 4A A2 E2 4B DB B9 58 + 4A 88 66 8F 3A 66 46 09 6C 3B B1 BF 2F FA 57 F0 + ED C0 DE 9F 98 A4 C3 4C 4B A1 4A 14 CF 5A 2B 02 + 60 0A 5C 14 F3 FF 6C 5D 28 8F F1 76 5D DA C9 76 + 53 03 09 27 14 68 D1 A2 F3 A2 98 23 6D 74 FF 10 + 0D +-------------------------------- + +:Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 7A 2D C4 F0 B6 65 27 93 E2 7C 21 94 3E B9 EF E5 + 9F 82 F0 EF 2C F8 68 9C A7 53 1A 40 AF 2A 30 7F + 6A BD 4B 3E 1F C4 56 CE F3 75 7C 8F E2 ED 1E 8B + 35 89 72 9C 78 55 D5 2A 18 C0 D7 57 ED 58 FC 85 + 22 4C 94 13 B2 CE 19 C9 3E BA 53 78 4D 9A 43 07 + D6 AA 3F 42 22 68 18 0D CF FE D6 60 F2 17 04 D8 + 49 6F 7A B6 D5 26 34 A5 44 64 7D 25 88 86 4D F4 + FB A3 5E 83 78 A4 03 8B CD 4C D6 18 A0 8B BA FF + EE BD 7C 60 4C BD 56 A9 6D 05 6E EF 15 25 2F 8E + FE FD 2F 97 0F F4 A9 65 96 3D 36 32 21 5E 5F 88 + 72 C7 43 EC D7 94 D5 14 0F BD 05 DB 42 1D 89 78 + BF 2F 8C DF A6 F2 3F CF 4A F6 95 60 1E B9 46 16 + 29 AE 64 38 5A BB 73 69 45 F2 D7 84 E2 8A 1E E7 + 63 0F B2 AB F5 94 FA EE 98 87 ED CF 4F 99 32 CD + 8A C5 0E FB 3D 2F 3B 4D D9 69 85 64 B8 07 2D 5E + 12 68 5A FB 20 20 13 05 7D 74 2A 3B CC 3A A7 A2 + 84 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 16 F5 D4 59 8C 6E 04 D2 3B 8B 5D 9A 15 8A 44 9A + D4 29 C5 9A 10 65 E3 73 83 A4 5A F6 94 E5 48 32 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + F5 CB 66 AB 3B C8 30 A8 02 DB E0 BD 51 A4 2D 82 + EA ED ED 6C C0 22 1F B7 97 0D 25 3C 20 D1 44 D2 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + C2 B3 00 31 4C 0E 66 DC 3E 2A 44 29 B1 F6 3D F3 + C2 E6 5C 88 65 E7 C3 85 BA FE A4 2C 9E 2C 6F 42 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 50 B5 47 16 9E 1D 40 1A CD FE B3 56 34 F3 B3 1F + 0E 35 77 2B A3 A9 7C 1D F7 06 66 7C 9A 3C 2F 27 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 0 bits, data = 'zero' + +Message data: + (none) +Result: + D3 F7 26 3A 09 83 7F 4C E5 C8 EF 70 A5 DD FF AC + 7B 92 D6 C2 AC E5 A1 22 65 BD 5B 59 32 60 A3 FF + 20 D8 B4 B4 C5 49 4E 94 54 48 B3 7A BB 1F C5 26 + F6 B4 60 89 20 8F DE 93 8D 7F 23 72 4C 4B DF B7 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1 bits, data = 'zero' + +Message data: + 00 +Result: + 3B C5 5D 39 B3 F1 1E 05 A4 53 67 4F 64 03 02 EA + 7D 8D 8D B5 05 A5 0B C5 1F E5 FA 19 7F 61 76 71 + 1D F8 CF 82 DD AC 0B 9B D7 9D 8C 01 27 AB AE 5B + 88 97 31 C1 C9 4B B1 58 72 CF 28 A4 7E CC CD 2E +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2 bits, data = 'zero' + +Message data: + 00 +Result: + DD C6 C3 CA CF E8 22 B5 B8 94 83 43 C1 2E B0 1E + 04 9D 52 3C 65 C0 25 A7 EA 6C 6E E2 C6 20 D6 E6 + 84 97 95 B1 99 4A F9 C8 FA 2C 97 12 63 1A F0 F0 + 23 0B 84 C0 2A BF 3D FE 09 1C 6D A4 CE 4C 52 BE +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 3 bits, data = 'zero' + +Message data: + 00 +Result: + 94 D2 C9 82 26 29 C1 02 E2 ED FC D0 71 6C 68 D6 + 1C 4C 0A 4C 53 98 5F 67 F3 34 2E 50 14 79 82 95 + 12 0C 19 6C 48 05 25 16 4E C3 EA 65 EA C7 E9 71 + 3B 38 3E 93 78 C9 2D 0B 33 62 E2 0F B1 57 23 CD +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4 bits, data = 'zero' + +Message data: + 00 +Result: + AE 20 90 B6 E6 AB A5 E7 9E 50 D9 F6 8B E5 46 FC + 17 9F B9 97 57 1C 17 A9 82 61 E1 76 B6 CF 87 41 + 4F 11 60 C8 BE 6E B4 68 2B 11 B6 31 CF 19 44 DD + 26 F8 A0 03 E6 99 D2 61 26 D1 A2 D0 40 A2 5D 5F +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 5 bits, data = 'zero' + +Message data: + 00 +Result: + 58 40 BE 7B D3 04 01 A8 DD 63 0C 59 1F BB 9A D6 + DB 49 90 39 04 73 0D 3D 61 4D B3 4D B1 89 BE 82 + DE 17 EE A5 74 66 14 7B 6A F5 1F 1C 75 40 23 B5 + F3 F1 7E 49 89 5F CA 00 E4 E3 70 A7 87 1E BA 4D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 6 bits, data = 'zero' + +Message data: + 00 +Result: + DC AC 56 C8 15 68 9F 73 0D D4 6F 4D 4C D7 94 3E + 4D 68 65 59 5E 18 20 8E 2F 3C 5C F5 75 BA B4 9D + 53 A4 D7 7A E7 D9 AE B4 81 16 DC A5 63 91 C7 37 + F2 05 61 1F 53 26 8B 55 90 3A 88 E1 6B AB 25 FB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 7 bits, data = 'zero' + +Message data: + 00 +Result: + E8 64 9A D7 42 7D 17 AA 34 1F 84 E3 1C 02 E1 A6 + C0 4A 96 AF 18 5A 1B FB 85 4A D0 05 65 12 01 58 + 57 CC 31 97 C6 40 14 95 1F 2C 8C 67 1E 80 67 27 + E8 77 A7 F6 53 0D F1 DE 2B 8E 04 8D F2 BA 6F 39 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8 bits, data = 'zero' + +Message data: + 00 +Result: + 12 38 C5 EA E9 EE 54 10 56 FE 9C 9C 8C F9 C5 D7 + 23 BC 31 8A 7C AF 29 F9 BC 8F 41 E8 AC 9F 8E 36 + C3 71 C3 F9 1D CE 30 2E 32 63 1C 28 A5 A1 5B 27 + 51 F4 4E 9A FF 6A 9D 53 8A 52 65 94 37 2D 54 AC +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 9 bits, data = 'zero' + +Message data: + 00 00 +Result: + DD B8 2F 28 59 DE A8 B7 D7 8D F5 6F EA 89 CC C0 + E0 6B 9D 69 ED F3 8C AA 47 F0 C0 E5 6D 8E 89 D2 + 48 77 6D 9C 77 1F D6 44 D7 8A 01 81 15 3C 55 2F + C1 23 43 4F A6 06 ED AE 66 60 AD 4A 0E 86 6C 0E +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 10 bits, data = 'zero' + +Message data: + 00 00 +Result: + C3 BF 17 5F BB 65 F1 A2 50 7A 51 20 B0 06 68 D8 + 9A A4 EB 39 2B 7D 15 62 F8 EE 8F 0C 65 53 A0 CF + 35 2E 71 20 CB BD D0 63 50 59 B8 4E 5C 7C CE D8 + 3A D6 40 3C 54 83 2D 2B 5E D0 94 B0 70 B9 CE CB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 32 bits, data = 'zero' + +Message data: + 00 00 00 00 +Result: + EF 01 FA CF 79 C4 CF F1 A1 DF B7 65 3F 46 25 81 + EF 26 0E 84 3C 02 3D FF A9 B4 C9 8F 47 38 02 E8 + 4A D7 D2 40 C4 DB 04 32 37 52 5B 6A 68 96 2E 1D + A1 7A 7B 1B 71 23 31 0D BC 86 2D 8C EE 3B CD 3C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 64 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 +Result: + C0 D7 6A 66 14 2A 59 A8 EA 34 1D DD E8 E0 BA AF + DC 8D F2 DC 19 B5 4C 19 09 39 18 F2 F2 06 71 B1 + 24 D8 EE 32 2E 41 B2 88 FC 5F DA 62 86 6C 1E 43 + 5F 5F 3F 08 88 02 FF C0 97 9C 78 6F 45 36 16 1D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 128 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 58 46 3B 6D EB 57 5F E8 49 B0 A2 BF E5 5D 6E 72 + E4 6E D8 84 0C EC F9 71 D1 1B 3F B6 54 83 B0 0C + EA 6D 7E 94 4D 01 7B 37 7D E2 50 BA 92 3F C8 36 + 0B 15 FF 6E D9 69 36 9A 62 40 3E 70 EE 9C 47 34 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 192 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 +Result: + 21 C2 A3 05 A3 9F DE 91 6A D5 26 FA F9 E6 48 62 + 6B A0 71 1B 9F AA CA 4D FB 39 80 B1 11 ED 55 98 + 12 B6 83 56 BF 90 85 C8 83 1E 4A D7 CF 14 9B 3A + 45 B7 5E 3C E4 22 4B 90 8D FF FA 40 CE 98 D1 C2 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 255 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 77 77 E2 B4 3F 05 DF BA E0 1E 90 B3 7A EA 61 93 + 8F B0 01 76 09 F3 DF DA 1D E6 46 A6 44 C2 7E 93 + AC B5 93 E3 FF 8A C8 AE BB BB A8 65 20 79 24 E3 + C8 A7 4E B9 CA F3 35 86 62 9E 3E 68 11 14 0F 89 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 256 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 74 94 4E 70 41 0A AD D0 49 0A E8 9F B8 22 C5 F0 + E7 EA 58 88 8E E4 E0 4C 23 F7 BF 5C 8F BA ED 81 + 1B 20 BE 84 BD 43 59 49 3A 95 25 E2 BE 2B 07 FE + 4F FF 34 1C 03 D4 C4 1F DA F0 E1 89 BE F8 7C CA +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 257 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 0C 77 C0 45 BF 09 8D 63 80 AB B0 C2 2E FD E5 43 + 7A 99 04 F7 58 CF F4 55 FE C0 38 DB 0E B9 02 C4 + 38 0B 9B 19 FB 21 0E C9 2A 85 53 DE 42 83 10 E6 + FF E7 B2 81 37 2C 51 5A 6E 8D F3 57 9F DC 65 D9 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 384 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 74 AF F8 EE 54 A2 62 83 E6 93 1D E6 C4 0B 3C D7 + 69 DD DF E8 E7 1A EA E9 E4 40 3F 19 D0 A1 FD BA + 50 5D C5 1A 32 A4 20 0E 52 C3 2C B9 0D D9 CA 2D + 8D DE B3 9D B8 99 DB 90 BE 23 1F BE 3D 7B BC 6A +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 511 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 74 84 78 BE 2C 0D 8D C2 32 4F CC 4A B7 B2 37 36 + 29 B1 04 FE 2E F2 47 D3 F0 5D 06 8F A3 EC 15 DC + 9F 8E 55 72 12 04 B3 A3 15 A2 4C 37 19 6A 1A A1 + 26 DD B8 F3 02 83 F2 07 93 FE 59 61 BC 73 AB 5B +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 512 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 34 18 6B B9 E0 41 A6 6D 7E D0 1C 64 93 A7 E3 EA + 27 CD DF 88 A2 9D 3B E6 10 36 A2 0D DE 4D 5E 90 + 42 E9 6D 4F 47 2F 46 5B B5 FB 7F 59 0D 35 81 BA + E4 1E 74 15 30 ED 5E 27 36 D6 F0 13 D4 9E 1D DD +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 513 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 5F 2F A5 67 03 A7 E6 9D 6F 1A 75 78 05 94 F3 57 + 94 0E C5 43 3C 0C A3 99 DC 02 94 AD C9 7D 8E B1 + 83 FE 35 CB 48 8F 0F C1 2C 20 80 6B ED FE D5 43 + 54 08 C3 CF 7F FD 8D F3 B7 06 36 EE 20 FF 8D EF +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 768 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 00 17 3B 95 5D 29 BE E9 7D 7C 3C C8 2E D9 77 09 + 3E 13 61 97 70 E9 C9 A2 5E 67 88 AE B9 62 CA D0 + 8C E1 76 D1 69 FD 5F B3 C0 EB F9 33 48 6E 5D B9 + 09 50 1E A4 F1 83 7B 39 14 9B 34 56 77 ED AA 7D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 63 FE 67 CA DF 04 06 6E C8 CE 4E B1 51 DA DD 6F + B5 C0 9C 72 80 20 FE DC 6C 5F 47 74 05 35 50 22 + 17 2A AE D7 75 1C 59 4E 0A AD CD 2F 2D 20 0F 78 + E2 19 8D 2C 76 B9 5B B8 37 EE 32 69 A8 2E 8A EA +-------------------------------- + +:Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + BA 41 95 FE 2D 05 6D 30 19 3D 27 03 D8 D7 10 64 + 41 48 A7 33 +-------------------------------- + +:Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 2A CA 9C 9A 51 03 78 CC C3 A3 1C 1F 80 ED 41 7D + 60 39 6D 79 B1 78 88 F4 3D 88 EC 3F +-------------------------------- + +:Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + C0 14 4F 4A 2A AF 9F 53 4D DD A5 A7 6A 42 B8 72 + CE 3C 38 16 61 C4 FC 94 23 67 50 3F 18 9F DD 84 +-------------------------------- + +:Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + A7 A3 F2 36 39 99 90 F7 B3 41 A2 BD 29 D8 97 5E + 88 48 7D D4 2B BE DF 4A 05 8D E1 42 1D 7B D5 EB + 92 7F 41 40 E8 D8 22 87 8E 2A 7F 26 1E 69 3D B5 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 22 A0 14 4C AC 4B 33 4A B2 F5 B4 BD 8B 32 C3 A3 + 48 05 B5 55 3A 80 62 86 87 EB 90 03 51 22 39 58 + 41 4B 84 33 24 EE 6E 14 80 DD 82 F4 47 0B 0D CB + 4F F6 DF E3 3A 72 18 E5 7B 75 3F 09 B4 BD DC E7 +-------------------------------- + +:Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + D7 53 67 7C 51 82 45 1B 59 8F 33 AE 6B 41 70 90 + 7C F6 1F D8 2D C6 55 0A A7 47 B2 E6 1C B3 59 47 + D7 5B 51 5B BF A0 00 E5 90 1B 37 7C DE 47 F8 BD + 9A 7B 53 DC 8F 11 19 48 69 E7 40 E6 05 92 44 4D + 84 E4 72 43 13 A5 76 C4 00 42 AE 09 2E EE 41 EF + 54 A6 1E B9 04 7E D7 4E 54 1C 45 6E FC AE 55 B0 + 9B 0D F3 C3 B2 89 E8 7A 55 EA BD 4C CD 39 44 00 + 0E 43 DE FA 14 3A C4 DD 74 50 12 1C C1 77 88 6D +-------------------------------- + +:Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 9E 82 39 3E C4 51 4B 78 CD DC C6 28 F3 3E A9 26 + B1 CE FE 89 89 9F 28 6A ED 28 C0 10 30 E9 B3 FC + 0B +-------------------------------- + +:Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + A1 73 9F 4F 43 65 B3 72 B2 9D 1C BF E0 D7 77 46 + 79 07 BB 38 4E 15 77 EE 7D C3 96 7F 64 2D 12 26 + BD 69 BB 60 CA 2B 93 8A AD D1 41 36 7D 43 35 22 + 09 47 56 53 B6 08 45 B1 81 11 DF DC 3D 7C 05 DC + 2E +-------------------------------- + +:Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 65 42 6C 1E 47 38 76 25 E5 19 45 18 3B B5 F6 3C + 87 61 78 18 DE 61 B1 AB 74 63 25 D8 4F E4 CF F6 + A1 05 B9 3E 62 EE 42 23 6B 3F D6 0D 66 72 DB 25 + 74 34 3B 61 80 17 BB 13 8F B0 ED 80 B4 63 D9 B3 + 11 4D DD 9A FE 04 06 3F 93 23 52 BF 78 CA 94 38 + 7D 3B EB AB 30 63 AC 8F 70 29 34 90 BB 32 18 EE + 0F EE 0A 85 62 6F A5 5F 59 37 62 E0 59 63 9F 1E + 6D EC B3 C5 8F AC A2 75 F5 9D CD DF 60 AF 48 AA + 59 +-------------------------------- + +:Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 91 FB 69 E9 39 42 B4 0A E8 2F C6 20 9C 40 7A 57 + 7E 72 48 34 30 D2 4D 7A 18 C7 2D 80 C3 AA A0 7D + 99 06 A4 E0 48 8F BB 43 CB BB 87 38 12 AB CE 06 + 4C 9A 5E 65 E7 52 1E 57 95 5C 6E D1 FB 01 37 CD + 6A 0F 0D 23 6E FE AA 57 DB 2C D7 31 0D 37 FE F5 + 8C 77 EA 79 2F 68 98 CC 95 93 42 63 7F 67 18 F9 + 51 63 AB CA B8 61 00 BA 6A D7 1D 6A C6 51 87 F4 + D1 1D 26 D7 53 85 3F C0 3E DB C9 09 48 6F 1D 9E + 68 60 42 DA 29 56 48 22 92 7F 4C 16 61 5D 0B C6 + 39 92 9D 65 52 53 A6 74 5F E1 17 59 61 13 55 F5 + DC 67 9B 8A 3F 97 D2 52 BE 98 4B 9B D2 39 A1 A1 + EE 40 15 C4 24 0D 9C 25 1D 63 F5 E4 6C FF C6 56 + 90 85 33 CA CB 16 8F 8D 12 D4 13 51 40 09 AA 3A + 18 72 93 50 96 1D 7B 48 49 2D 3D 96 C3 F2 3D 7E + 12 9E A1 DB AF CD ED 87 E7 58 4E 50 6E D0 0C 75 + 3B 14 45 28 16 45 C7 AD 5A FE 53 5B 13 15 9F FD + 62 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + A5 42 44 26 64 79 71 A1 2C 01 67 C0 F7 8A 85 C2 + 1F 62 92 0B C3 96 BC E0 67 1E 42 F9 91 2D 8C 43 + E6 A3 DD E5 EC E7 A2 E8 17 C7 D1 AA FA C3 FE FC + 2F 36 6B 05 C0 60 9A 02 30 20 36 41 95 CB BC 04 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 28 1A 77 0F EE 37 FC 64 D9 ED 9D 47 33 D9 77 DA + CA BC 11 E0 0A 58 24 76 77 68 4B A6 44 B5 54 3B + 88 16 28 0A 40 F8 EA 65 4E 23 75 5F 3C 01 45 72 + 1F 01 DF 8B BD 79 D5 1B FB 2E EC BC 59 A2 6D 70 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 79 05 C5 25 C8 2A CB 94 E4 BF D6 85 64 42 79 EF + 2C DF 6E 5A 9B 39 42 C2 2B F0 EF 32 76 64 39 CC + E4 6E A0 E6 D3 22 74 50 3A 3C 4F D2 8C 11 8E 55 + CB 80 A0 69 B0 AC 4A 46 51 D6 0E 1E F0 AB 9F 07 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + D8 91 0C 4E B4 28 25 C4 60 3D 6C 7A 02 79 EC A1 + 1C B7 CE 4B 64 D1 6F 19 8C 96 F6 52 64 5F 70 01 + 88 04 4B DE 8F B5 4E A3 F1 6A 64 11 2B 13 8F AB + 7F DC E7 C6 33 C4 BE ED AF A4 A7 05 6D 83 A7 3B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'zero' + +Message data: + (none) +Result: + 7B C3 CE 31 C0 35 DF 3C 7A 7D 55 9B C9 D9 45 4F + 87 9F 48 49 7C C3 9E 6D 14 E8 19 04 98 45 5F 39 + 6F 45 59 04 05 C4 A1 5B D0 AB 29 F5 46 7D 91 32 + 80 2F 43 54 37 6E E8 64 AD 9F 20 0E 39 A3 D0 9B + 9A D0 6E 9D 0F 65 6C F9 1E D9 DE AC 13 A7 A6 7A + 82 AB 98 3F 52 13 31 29 CA C2 A4 DC 13 FD 29 C3 + 6C A6 C7 2D 6D CC 6C 82 C6 67 97 F6 B7 60 7C B0 + E0 F9 00 6A 27 B8 3B 60 C5 9E 4B A1 8D E2 33 E0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'zero' + +Message data: + 00 +Result: + 42 02 27 3E 1E 8C 43 E0 14 85 4B CF 83 EB EA 60 + E2 A3 00 7D A5 9E 2B 02 8F DA 42 4E 3E DB BB F1 + F4 82 AC FA 83 A7 C3 81 8E A7 5C 60 45 23 F1 BC + 0E A7 54 8B 7C C4 65 F3 93 10 77 62 EA 9D B9 2D + 52 FF E9 90 CE CB 67 99 90 9C 02 D4 F6 A0 7D 29 + 30 06 32 C2 9F A6 F7 92 C0 E2 EE 47 FA C9 CC 09 + 7F B1 F3 24 BF AE EB 60 FD D6 9A 90 50 5E 13 ED + 5D 53 C2 57 2A 60 C4 49 6C 54 B8 C5 1F 97 7D 80 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'zero' + +Message data: + 00 +Result: + E4 04 26 2E 59 F4 E8 38 8C 70 EB 7C F4 0E 9C B2 + 03 F0 EA B1 57 53 24 2D 5D D2 74 86 74 09 2A 44 + 61 23 CA 52 E0 80 47 02 AC D0 7A 8D DD 11 3B C7 + 33 5F 30 D9 0C 47 8B 95 35 40 92 3D F0 1F 8B 06 + 08 E8 CF B1 EE 63 63 FB 69 17 0B 87 A2 54 B7 5E + 6E A4 0F 21 AD 6B 5C 51 18 F4 8B 70 BC B9 9B 32 + F6 15 47 E4 6F 1E 85 67 91 3A 45 6B 73 FC D4 53 + B1 49 33 67 35 9B 2E 64 D6 8A 56 57 E0 4E A1 99 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'zero' + +Message data: + 00 +Result: + 25 EC D2 2D B9 C2 22 16 72 0C 9A 57 70 97 F2 5D + 67 33 8E 58 16 C5 FC 39 53 1D 3A F2 BE E4 C7 C2 + 56 B8 67 26 EE 42 64 F9 CF D2 F4 97 B1 AA B7 D2 + 41 F9 1A C4 D0 EF 13 17 06 64 B2 15 43 65 A7 3B + 19 E9 8E A0 C5 2B D4 E8 2F 97 76 48 0A C6 1F 00 + 7F 74 7F 42 74 42 C1 D8 63 8A 3F 3A 5D 0D 97 24 + A7 18 05 9C 11 E6 7C F3 DD 38 47 0F 1F 2B B6 1B + 51 76 67 4A 33 E3 4D 75 19 16 6F BE 37 76 59 A5 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'zero' + +Message data: + 00 +Result: + 6E F2 21 4E 44 51 72 EB 1C 1C AE C1 DC 04 5B D3 + 07 42 62 FC 06 6B 25 48 9A 7A B7 97 36 4B 4E 13 + 57 28 39 3E F0 03 F7 FF 7D C1 29 2E 22 C1 04 21 + 7D D2 CE CA 67 BD 53 11 DB F0 7A 47 00 BE 4F F5 + 7A 69 9A 3A B6 5B B8 6F CA E5 5D 49 85 D2 06 50 + 51 D9 2F 66 AF 31 DE 62 DD 26 CD 4B 8F B8 2B 18 + 65 D5 84 8A CF CB 5A 60 35 2C 5D D3 3E 2F 2A FC + 8A FD 89 A6 32 03 E4 5C 7F EE FF 1C 4A 66 A1 86 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'zero' + +Message data: + 00 +Result: + 52 F1 A2 CC F5 6A D1 DF B8 68 3C 8A 8B 69 7D 66 + EE 2B 09 28 77 14 72 28 69 13 99 7F 39 08 D0 20 + 6D BA AE B1 81 98 9D 92 4D BB FB D6 5B 24 45 9E + B6 12 0F 69 32 39 DB DF 8E 72 A4 67 69 4F 9B AE + 2F 2A 80 5D 31 6A F1 58 43 37 14 31 6A 95 B6 27 + FC 3C 6C B2 5A 65 2A 87 64 AE 5E E4 59 E9 AA E9 + 0A 39 C1 16 45 5B BD 84 1F 26 22 C9 5C 96 07 88 + CF 01 28 7A 8C 9F 30 2C 3B 24 30 E3 7A A8 61 91 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'zero' + +Message data: + 00 +Result: + C6 18 79 07 5F 84 95 02 19 F7 CF AF D3 2C D2 68 + D5 DA 9C 79 97 58 FD C8 4B C4 44 C7 16 B2 EE 52 + 73 91 6E EE 4A 32 DE DA A5 1B 85 5D C5 10 12 A1 + 50 DC A1 40 61 74 C6 B1 85 22 98 E5 50 A0 2F 79 + 14 EB 33 85 AB 03 DD 8B DE 2E D4 DD A9 3C 07 68 + 7B 1A 10 13 77 DC 1F AC 46 A9 7D 6D EC 8C AC 23 + 6F 07 FC 5D 09 27 B7 AD 2F 7F 1A E0 1A CF 56 D6 + B3 0D B9 CF AC 7F 9B 3C 74 34 3C 6C D0 AC EA 2E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'zero' + +Message data: + 00 +Result: + 6E 87 21 23 9F B7 2E 3B 7E C0 8D C0 5A CA 12 B2 + 49 F5 EC 05 24 DC 33 1B 7B DD 50 8A 9D B8 90 1A + 27 DC 1C 7B 07 4B 4B C1 AA BF 07 6A 65 B8 A4 89 + C8 C6 64 90 9E 5F A8 92 A9 5F 0D 25 53 9D FE 00 + 09 7B C0 52 50 7D 83 EC A9 33 CA AA C6 7E B0 CC + EF 0B EA 2C BA 1A D0 46 A7 C8 0B D7 62 DE 6B FC + 5B 89 F9 92 48 F6 94 84 D0 D5 4D 03 1E 2D EB C5 + 8E 2B 7D 6A 81 55 E1 2B 1E C8 87 A6 E1 6F 69 F4 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'zero' + +Message data: + 00 +Result: + 5B 95 57 54 14 AA D3 0A AC 69 18 0D 3D 20 B8 F0 + FB 46 73 CB 09 56 72 01 88 E8 1D F2 86 CE 14 A8 + 9B 56 25 46 42 13 5E 41 5E 3A 6F 4D 10 B1 30 61 + 9A 93 00 6F 76 6B AB 1C E4 16 EA F7 7E 3C 4D 88 + B6 D6 CF 63 0A F0 4E 0A 25 71 5A 20 E0 F0 EE 4D + AB 97 19 A0 8A 89 78 03 80 60 65 5F E2 A1 B5 13 + 4A C0 D1 72 3B 79 89 EB 88 73 28 BB D4 A6 BE E2 + D3 F1 29 99 76 D6 19 F1 2F 05 AD 83 FA 72 7A 4B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'zero' + +Message data: + 00 00 +Result: + EA 9A AC 5F A9 58 18 C8 C8 4F 28 FC 61 86 25 BD + 65 75 B8 A2 15 47 D1 91 C3 34 DC 93 D9 34 5D E2 + 50 C0 73 EF 46 12 B3 26 5B 58 5E 10 53 48 70 BF + 71 9B 61 C8 52 DD 8E 43 48 1C 4D 51 36 D6 71 BB + 99 C3 1F 50 D2 FC 10 81 61 A4 6B 9D 26 D7 4B A3 + 96 34 C5 51 CC 94 92 86 1B 2D 87 22 3C A1 B8 17 + 5F 4D BD CD 45 85 DE D0 A4 80 9E AF 41 56 B8 2D + 8F 53 39 D6 F6 DB 5C 77 40 B5 52 85 59 DA 02 C2 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'zero' + +Message data: + 00 00 +Result: + 18 DE 3A A5 92 92 A8 A4 3C D0 E5 EB 8F 6C F1 B1 + B0 A8 9C 6D CF 4F 35 90 9A EA C6 F0 76 E5 59 9F + 70 0A F2 3D 67 02 23 CF 7C 82 10 DF D3 CF 5A E3 + 0C 75 93 6D 61 81 29 6E 32 27 EF 6E BB C1 03 1B + F2 B7 CE 2F 79 19 59 3A F9 14 A7 B0 10 BB 86 38 + 3A B3 40 05 F5 D3 62 C9 EE 70 CE 05 FD 0F 2D 30 + CB 1B 2F C1 1C CC D8 13 D1 64 47 40 48 0B 71 6E + BF 16 F8 3C D0 E1 01 9C 87 5F F4 ED B4 31 11 09 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'zero' + +Message data: + 00 00 00 00 +Result: + D8 12 A7 2F 10 57 C7 1B 11 21 EB E0 D0 33 05 72 + 16 0A 9A C8 79 01 44 75 60 6C 6C 81 FB 86 E4 E9 + 05 6B 05 96 EF F4 7A DC 07 B3 1E E7 BB 10 6E 6D + 57 9D 2F 32 8B 69 52 38 B9 41 80 47 01 25 D9 9B + A4 4C EC 17 9E 64 A0 52 C4 5F 77 63 F9 66 DD C5 + 11 E4 83 B3 5A B4 8F 66 F9 DF 02 7C 72 DC A0 52 + 21 80 80 14 EE B0 C9 CB A4 D3 73 83 EB 90 86 04 + 71 DE C2 D2 D2 7C 7B EF F7 6F 45 3C E1 A4 FF 89 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 +Result: + 28 BE A2 09 B5 B5 58 4F CE F6 31 3D 04 00 5C 34 + 9A 23 82 BE F3 3E FE 60 9D 77 11 5D 59 44 AB C1 + A4 72 F3 04 66 45 D8 B1 C4 2D 73 A6 EA 04 C0 02 + EA 1D 8F 7E 87 01 14 A6 B4 54 55 6B D2 2E 24 43 + 1C 04 57 3E D6 CA 25 9F 9E AB 43 D3 92 9B 89 3B + 58 67 16 14 EA B4 AC DB AF 69 9C 85 A9 D7 00 CE + 0B B3 D0 2E 60 21 C9 A5 81 08 D0 14 A6 9F 1C 13 + 8B 3B 7A E4 CB 1F 6E 7E 17 3F 93 19 DE BA 74 64 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + AA 63 B6 B1 03 C5 B9 D2 57 27 0C B5 BC 2B 70 0C + D8 1B 21 68 C6 73 76 6A 24 D6 1B D5 42 06 60 1B + A2 6C CC B8 23 58 6E B4 C5 99 51 0B F3 BF C3 D0 + BD 1F 4A E6 E1 74 99 5C C1 E6 E4 19 56 AF 92 97 + 46 76 31 74 0E 6F 41 A6 6C B3 4F BB 1A 0B E6 DF + 7C E7 2D 6A B7 F0 0A 58 EE 8C E5 80 4E D1 95 87 + C0 FC 39 6C 15 6F 84 8D 0B A4 84 1B 55 1B 17 15 + 3C 83 13 8D A4 CC 47 8F 54 A8 11 BF C5 D4 58 25 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 +Result: + 37 D1 99 FE 24 93 DF 31 57 6B EC CD 00 0B E6 25 + 63 D7 55 18 6E C6 C6 5F F7 AD 06 59 B8 BF B5 94 + 20 C7 D4 BA A1 D6 E4 26 58 F2 17 0A 74 08 22 4C + 1B 60 C3 CD 7F A7 4E D1 B4 D8 29 EF 61 B5 3F D5 + 66 AE ED 32 32 74 8D 65 4A DA 09 24 4C C6 54 D9 + BF C8 81 7E B3 84 0F D8 F6 68 6C D6 59 E5 0B 32 + A5 31 F6 EB 5C 30 8D 48 80 93 F8 34 46 5B 4A 31 + B0 07 DD BF 56 B9 D1 28 28 AD 8F C8 EE 1D DB 84 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + BD 86 94 2F 02 93 29 7A 75 16 DD 4E 31 FC DA C2 + 7D F0 53 AF 11 51 E1 0B 83 F6 11 0B 68 C3 88 85 + F5 6D F4 9E F2 23 A2 C2 BB 99 6D 8A 6D FC C1 9C + 9D 1E D0 77 4B 31 A1 93 35 F9 33 2C A1 29 C0 D0 + 1E B7 71 95 0C 2C 72 38 FD A4 BF A3 AF BA E3 B1 + 94 33 13 EF 15 8F 4C D4 82 E5 5F 3A 5B 3E 01 83 + 50 02 64 06 78 A7 C4 01 F6 A9 FE 87 BE 53 61 29 + AF 49 FB A2 65 AD F5 01 B2 B8 42 11 19 28 04 6A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 38 9A 02 C6 A0 F8 06 13 91 6F C9 3B 25 2D CD 2C + 81 90 64 B1 1D 4C E2 70 B3 A0 D0 69 A5 A1 0F D0 + 66 12 20 24 7E 9C EE E6 93 7F 88 09 2C 43 71 CB + 19 81 60 42 E3 A1 05 96 B6 32 76 D4 D4 46 F7 24 + BF 59 18 99 6C BA E9 9A 72 C0 9C EF 64 2D 07 F2 + 9A 30 F3 AA 28 1E 1D 8E BD BC C4 96 2A DC 34 6D + 52 ED 5D 38 35 CB 07 2E 9F BF 9F 0D 3D 98 5A FC + 3D 43 F5 14 51 52 8B 4F 0F 0D 64 95 41 7E F9 D0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + E4 BA 51 98 72 CF EF A4 F2 1F 08 15 8F C1 38 07 + 0A 62 C3 21 90 E2 3C 9C A2 AB 4B 8D 4B A4 B9 BF + B1 63 2E 8D 00 1B 31 90 E2 8E D2 0C 99 05 46 0E + CC 17 BC 8A 51 A2 93 37 A6 C6 11 EF F8 83 CD 83 + 23 4C 1B 23 ED 02 47 C7 AA 09 58 0E 20 55 51 D7 + 5C FE D0 ED 6C 14 99 1E AB 87 C8 D9 33 7D E9 C0 + 5D C4 4A BD EF BE 36 AE 55 94 17 AB 2E 60 12 6A + 94 70 09 3E 4F 1E AD FC 45 AF 53 C4 6F 30 C3 18 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + F5 AB B3 CD E1 26 A3 6D 78 C6 1C 70 C9 A5 E8 11 + EE 8A 63 8F DD 90 2A AC BC D5 F2 92 B4 78 46 D4 + 02 F1 25 C5 11 FD 13 B0 D6 E3 A1 78 2E 31 6B EF + 27 85 DC F8 B0 3E EB 76 96 F7 AD CF CD 2B FF 30 + 04 0B 54 9D 57 0F AF 9A B2 C5 2F CB A7 D7 E0 85 + 04 F6 18 A8 EF BF 5B EF B5 ED 7B 96 8D C3 9D 7F + 85 92 75 F4 9B 11 2E DE 4E 03 B6 47 B7 20 6E E2 + 16 BA EA AC BB 13 B8 52 AB 13 16 65 3C 11 71 AF +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + BA 14 5B 6A D1 F4 5C 2A 2D 0A 36 1F 11 E0 AC C1 + ED 48 AD CB 3D 49 F4 EC 41 41 85 94 C1 16 00 2F + FF D2 A7 FD D2 8B 93 C9 D1 C8 E7 91 AE 1C 28 E5 + 71 25 2A 25 F7 1E 56 86 AE 67 27 77 2E B6 3B 03 + 02 95 3E D7 86 F6 B8 C6 B7 A5 9D E7 93 D6 79 F9 + 31 53 D0 C8 75 1C DC 5A 43 5A D5 52 90 66 C8 C7 + F0 AC 58 26 6D 6D 9A B5 DF F7 0A 2F 64 E1 5D 14 + 43 92 60 F0 D6 12 7F 05 12 7D 37 0B FE 52 FD E2 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 3F 29 2C A3 25 E3 8A FD 1E 54 C4 8C BD 49 2E F2 + 18 8C 42 21 A5 46 E0 94 BD 00 CE 16 A9 5B C4 36 + 46 76 3B 36 8F 34 0E 01 DB B7 99 67 9E BD 7A 7B + 8C E0 43 6C CB 5C 21 A8 33 4E 10 95 B4 E4 55 BF + 1B 7E 74 C2 12 3E 30 01 BD DA 52 B6 47 51 B1 02 + F2 CF 03 09 7B 1C 86 AE A6 A1 58 B5 7A 65 98 71 + 1F F4 66 5A E3 33 A4 36 9E 61 C6 69 C6 7A 1C E6 + 48 60 99 A1 CD B9 30 3E 0C 46 3A AB C2 A0 15 09 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + 04 66 3A 5E 71 CC FF CE 26 81 59 2B 5F A8 A2 9E + EA 81 20 92 13 C7 41 8E 11 27 34 AF D8 BB 3B 63 + FD 51 9C 02 9F E4 05 89 1D 23 12 F1 2D 32 D1 D1 + A4 7E FD C7 C4 B9 09 8E 12 B2 C8 8C 2A 10 EA FE + DA 54 53 EA 15 63 BA E0 D4 B7 2A A9 99 22 12 60 + 43 78 42 4B 45 5F 98 83 B2 31 6A D6 3B C1 D8 9C + 68 FC 10 1E 50 ED 36 94 6D 94 06 94 DE 6F 29 BC + C4 6E A3 A2 D2 13 37 D6 67 33 3F 29 C6 68 92 3A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + D6 C9 C1 B3 41 1E A5 B8 28 89 83 15 16 8B 09 E8 + 09 E9 C8 1B 76 D4 ED B8 34 43 4B 07 9C 6E 07 DC + 4B B4 82 9C 1B 81 37 E7 87 A2 1F 7C EC 03 8D 68 + 75 E1 CA 2B 2E 13 C7 A2 F8 F8 A3 7F 41 C3 26 EE + 32 B4 10 12 43 FC CC 61 A0 AA E0 C0 4C CB 00 33 + CE 06 2B AE 50 79 AD 73 D4 4C A2 D5 F1 6F EE AF + 22 60 70 13 49 F1 A6 D1 9A 87 C9 E0 A2 AA 98 9C + 12 86 50 BA 81 7A 87 C4 06 AD 4F CF 79 65 84 05 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 7F 50 39 34 D2 AE 74 6D AB D0 19 B2 5C A5 8B 0F + CE DC 94 91 B7 0E C8 5A 66 C2 74 A5 DB FE BB FA + 77 62 C5 BF 45 41 9C 14 65 F4 8E 37 A3 6B 88 F7 + 19 B2 DD 8C 96 F5 75 EA 29 54 ED 7F 41 66 52 2C + 54 43 DA 84 15 AF 18 CB D8 5B 78 67 9B 00 BC C3 + 86 97 1D 9F 54 36 A2 34 00 AF A7 6F 40 93 73 FA + 0E 97 46 CC 69 22 29 F7 C6 27 B2 C9 7D AD E8 D3 + 68 C8 D9 D8 13 4B 66 BE AE 85 2D 0E FC 11 12 76 +-------------------------------- + +:Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + D8 27 A1 08 26 DA DA 69 FD 4E AE 87 2C 02 74 BB + 62 8A 50 BF +-------------------------------- + +:Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + FB 48 ED 84 E2 FD 1E 36 68 C8 96 0F A9 6F 66 C7 + 31 32 D3 D9 00 F5 96 23 F9 CD 5C 6F +-------------------------------- + +:Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 14 0A D9 DC 20 0C E4 7E D7 58 D8 9D 3C 5B 69 75 + 1C 20 D3 94 82 EF A1 49 C9 F1 0B F5 2B 57 21 AD +-------------------------------- + +:Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + A0 90 0F 17 71 1C E8 2A EE 81 04 DA 6D 3B 94 75 + FD 92 E4 50 01 7A CF FA 08 03 F1 F1 80 DB A1 D7 + DF 68 81 44 F7 59 67 EE 47 3C 23 ED 3F 98 54 E9 +-------------------------------- + +:Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + F3 52 6C 3B 8C DE 9E BF 39 71 87 04 03 42 62 45 + 30 94 95 41 38 7A 54 91 40 D7 6D FA 79 78 7F 92 + E3 39 B0 44 35 89 9D 75 34 86 A2 0C C1 3E 5F C4 + 74 81 27 1E 27 6D 19 3D 22 CA EF 22 BD BC 11 A4 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 69 E0 D6 82 E6 B1 11 F1 D7 1F 6F 1A 43 AE E6 79 + 67 A1 E7 DC CC 37 EE 95 71 2F 81 4E 6D A6 3A F3 + EB 5E 8A AF C7 AE A9 E9 6A 11 2F 30 F5 61 BA 6E + 6D 19 82 AF D3 C8 22 E1 8C 1C D0 B8 F3 3A 78 2C + 4B 1B D4 44 8E 17 36 19 35 D4 5F BD EE 4E 0E DA + 16 25 EF 08 75 8D BE D3 2A 7D 4A A3 11 E2 B9 E1 + D0 A7 00 97 63 49 26 78 DA A1 D8 30 80 62 0D 2D + CC 9A 9A EB 18 80 31 46 0B 85 DB D8 01 3E 22 61 +-------------------------------- + +:Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 57 89 31 97 1C 10 D3 93 09 92 8C 25 63 1F FE BB + 11 38 9E 12 FD A0 AC BA C8 8F BE 1F E4 36 CE 0F + 00 +-------------------------------- + +:Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 2C 9D 30 D5 B8 B5 D1 A6 DA 74 22 91 9E 9A 88 B7 + 44 DF 51 49 3A D0 7B 45 1C 5F A8 F7 5A 53 1D 86 + EF 95 A4 A1 59 05 E3 BE 1B 45 00 0B AD C4 4C AD + E4 B4 9C 3C C0 E6 65 98 79 56 5E 79 87 58 EF 41 + 7D +-------------------------------- + +:Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + AB 74 5F 14 4C 9A 58 88 C1 13 82 C7 F7 C4 7A 8F + 2C A5 5F 40 C2 F6 32 82 74 16 51 EB CE 3C 42 F5 + 2D C9 81 4C 16 CF 12 74 C2 4F 92 DF D3 BE 24 B4 + 93 83 53 84 32 FA 89 4B 63 A5 D4 76 16 35 DE E0 + 69 48 28 FE FE 6A 9A AA 31 83 32 C6 66 16 E2 F0 + 88 21 4E D8 4F B0 AA 34 85 77 7F 2D 10 3A E7 1F + FA F7 30 7A 23 C2 48 7D A5 45 87 43 7E C4 61 35 + F9 95 DF 81 2D 6D 12 31 62 3A 1C 8F 35 4C A7 90 + BA +-------------------------------- + +:Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 40 ED F7 CD 4B 45 92 6B CF 5B 84 0F A4 7F C6 E1 + E3 40 86 E1 04 43 A2 9D 57 D3 D1 00 75 D9 FC 1F + BD FE 4C 18 CB 82 BF FD 73 C7 8B 06 F1 7E CC 92 + 05 1E A5 75 CC 39 30 83 2B D1 C1 FE EF 15 DC AE + C1 A5 92 AC 10 5E 54 A1 52 4B D8 7E 26 67 0C 0A + 6A 6F 27 00 A5 B3 D5 FF F1 12 EA 11 2B 6B 12 0F + 99 1F 6B 10 33 85 55 BD 17 D6 28 99 5D D8 AB 5B + 01 A0 8B 5E 64 CB 9A 5E 73 7C D3 17 1F F9 0A C5 + B1 5F A9 99 62 AB F8 00 9D A1 B5 F3 5B 8A 30 F0 + 7C FE 6E 85 40 52 B3 6A 81 3C 34 E4 22 B6 22 36 + 86 19 7F 97 7B C8 A0 59 C6 1D F2 13 27 2C 1D D1 + 2C CE 33 7A 4F E0 11 AF 00 8B C0 17 7B CF 2F DA + B4 A0 2F 26 42 1A BD E2 80 99 35 04 A5 30 FA E2 + AF A5 B5 3A B4 FE F1 35 66 FA 9C 5C DF B6 B6 53 + 0F D6 C8 8B 24 AF 51 7B 9B E4 79 12 67 7E C1 94 + 45 2C E1 DE 56 33 A6 9F 20 17 B2 E0 9F AF 35 21 + CA +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + AB 9F 39 17 CD BF B8 AE 35 D6 99 13 C2 B5 DD 17 + CD 6F 6C B9 16 FB E2 AE FA F9 2B D6 19 2E 97 8C + A8 DC 70 EC C6 B5 81 D5 CD 3A 89 8E 0F 66 D4 A4 + A4 42 EE E4 FC C3 11 05 D9 EB 68 07 C2 1D 9B BE + 49 C8 96 29 81 FC EC 8E 75 0A 0D D7 25 D4 55 19 + 16 AF C8 DE 09 C5 A0 B6 D2 9B 91 3F D1 BB 62 FE + 0E 2A 37 1A CE E0 32 E9 ED C9 59 36 60 E1 60 E4 + 47 A3 30 35 CC F0 B2 23 D5 D4 D9 1E 4B F9 84 18 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 9F 00 98 88 83 98 22 C7 E5 DF 03 E3 8C D3 B8 8D + B8 00 8D 12 47 46 DB 96 79 12 C8 BE 14 50 9E 9F + 5C 55 9D 07 2D 68 E5 8B 13 17 FC B3 04 AD E0 38 + DE 1E 5F 10 BC 47 D0 39 EC 95 69 95 4C 96 55 42 + 47 27 06 58 30 5F A3 1B 28 17 C9 83 16 02 0E 3F + 39 41 64 A9 0A E7 15 91 9E 49 A5 B4 58 7D D3 EA + 91 EB CB 57 4A D0 30 63 22 18 5E B0 ED 9C 4F 95 + F1 DD 9F A4 A1 58 B2 58 EC 24 B5 A0 3E CC B5 E2 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +Result: + 4C 2E 9E 13 08 C8 6A EA C4 07 88 A2 49 82 79 4B + FB 74 2B 58 41 20 2E FD 0D 04 A8 47 57 46 40 B3 + B9 8F 43 BE 2F E2 B0 56 D9 28 FE C2 3E BD 71 BC + 4E 77 72 20 35 0A B9 C6 23 EB AD AC 60 E6 AF CC + 79 F7 38 27 26 67 92 58 73 72 3D 08 8F 14 A2 CA + 1F 59 3F 7F EC 9A 99 8A 25 4E C4 E1 28 35 9D D7 + DD 77 47 3E 9B 4B 17 C7 1D 24 0B 8E DC F2 E5 80 + 34 CC 70 8F 3C 0B D6 9E F3 33 D0 D2 DA D4 23 6F +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'zero' + +Message data: + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + 00 +Result: + B0 89 82 E5 B8 74 9C 9D 7A F7 3D B5 D5 65 EA DB + 70 70 69 22 9C 5C F4 1C D5 29 3B D7 3F 12 75 9A + D9 58 B6 60 82 DF 22 66 2B 53 49 D9 02 06 F9 54 + 51 41 3C 2C C2 A6 53 D4 E4 F9 EC B9 69 93 BB 5D + 5E C6 B3 0C 49 72 E3 FC B9 23 C9 21 F9 3C 79 5D + 63 5E CC 7E BF 26 78 7E FB EA DF DB 0B C3 D5 E9 + A3 24 2A 3C 11 DE AB D4 B5 ED 5E 00 F0 75 B0 A1 + 7C AA D5 5E 7D A1 A2 27 60 4D DC BB B9 84 02 FD +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 0 bits, data = 'incrementing' + +Message data: + (none) +Result: + BC 27 63 F7 07 E2 62 B8 0E 03 13 79 15 43 A7 AB + 0A 4B 6C D0 83 27 0A FB 2F CE 42 72 E1 BB 0A A9 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1 bits, data = 'incrementing' + +Message data: + FF +Result: + 95 D6 9B 85 23 E6 AB 6C 56 A1 E4 F5 93 A3 15 8F + 97 DD 61 42 49 A6 10 D3 13 0C 88 9E 3E EE FC 1C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2 bits, data = 'incrementing' + +Message data: + FF +Result: + 0A B7 09 B6 40 36 4C 25 FE C8 86 53 03 77 BF 53 + 5A E4 EB 12 14 A3 C3 FC B5 B9 6D 6B 5D 09 E8 08 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 3 bits, data = 'incrementing' + +Message data: + FF +Result: + DC 6E 6E AE 34 80 B8 F9 57 74 AD 1D D6 B8 B2 18 + 6F 4A F0 A9 96 D9 60 F8 8F 75 5D 7D 00 CF 05 E7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4 bits, data = 'incrementing' + +Message data: + FF +Result: + 13 30 4D D8 50 68 E8 16 9F DD 88 42 84 AB F2 6A + 2F 4D EC 13 15 54 AA AA 7E 4E 64 F7 F7 74 14 1F +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 5 bits, data = 'incrementing' + +Message data: + FF +Result: + 89 E9 7B 03 C6 97 46 AF A4 E7 8D B4 9E D6 77 C0 + CC F6 63 54 23 56 01 66 45 90 7D 61 40 AB BB EF +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 6 bits, data = 'incrementing' + +Message data: + FF +Result: + C1 ED 43 94 70 52 D9 57 D0 60 55 80 A4 88 3D 07 + 76 D1 55 E9 AE AF 39 A5 0A 28 89 35 68 87 9C 4D +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 7 bits, data = 'incrementing' + +Message data: + FF +Result: + 9E AD 53 A5 53 F4 0C 90 4F CA 1C BE B4 6C 48 6E + CC 9C 7A 5B 78 38 05 4A 3E 28 B5 C2 89 F5 E2 B6 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 8 bits, data = 'incrementing' + +Message data: + FF +Result: + A4 7B E7 1A 18 5B A0 AF 82 0B 3C E8 45 A3 D3 5A + 80 EC 64 F9 6A 0D 6A 36 E3 F5 36 36 24 D8 A0 91 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 9 bits, data = 'incrementing' + +Message data: + FF FE +Result: + 11 CF B1 10 F6 DE 0B AC E4 CA 58 5E 70 21 1F 32 + 65 D6 F8 2B 1E AF B1 3A 34 75 72 89 FE 5F 59 FA +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 10 bits, data = 'incrementing' + +Message data: + FF FE +Result: + B9 1C 09 41 5D 2E E5 DF F5 13 9A 4B 91 89 96 B6 + 13 4D C2 28 53 70 ED A2 A2 34 D1 AB 02 26 54 8C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 32 bits, data = 'incrementing' + +Message data: + FF FE FD FC +Result: + A6 1E 60 21 BF E2 47 D7 5A A6 C9 02 70 21 75 CF + D4 DE 05 B4 92 AA 2D 39 9D AC 3F 66 B0 2E A9 3B +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 64 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 +Result: + 97 15 51 7C AF AC 81 0B C7 4A 0F CA 37 9E DB 11 + 95 EF B0 ED 50 E8 89 53 AC D1 39 0F 50 8B 94 AB +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 128 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 +Result: + 34 60 D8 0F 1B E5 43 D0 7F 2E 75 C2 5B E2 73 3C + CD 75 F5 66 B1 98 F0 2F DD C9 1C E4 F2 D4 8B D2 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 192 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 +Result: + A6 B2 18 17 BA 50 C8 E6 75 5B 24 8D 76 AA 31 0F + B8 6A AE 69 35 57 79 9A 79 5A 54 91 12 84 FD C0 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 255 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + 3B B6 47 D8 EF 8C 71 7D 8F DE BE 84 C5 D6 28 51 + F5 27 F1 FD 6E BF 0A A1 60 AB CD 12 4F AA BF 75 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 256 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + CC 2D A8 2F 39 73 C2 F7 A8 CE D0 BB B5 4A A0 28 + EC AF 6B 59 11 62 8D 0F FA BB 20 08 E4 11 D1 71 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 257 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF +Result: + 57 54 FF DB DC E9 AD F9 FA 48 1C A9 26 3B C3 1B + 97 F7 D0 B8 D6 FC 27 21 66 10 CA 11 84 81 A8 55 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 384 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 +Result: + AF 11 2F AE 4A A8 40 E2 7E 62 81 8D 06 61 04 75 + D9 56 8A 84 34 59 5D 49 D6 2F 86 47 AA 6C 19 27 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 511 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + B6 62 2E 02 24 A4 73 A4 2B 62 6A C6 19 B1 B8 13 + D6 39 53 55 EB F4 CA 57 63 F5 79 74 0D 32 0E 0A +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 512 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + FA 1A 76 2B 6B 1C 72 B7 0D 52 92 63 53 E1 0E B8 + FB 0E DD 73 13 DA 20 A2 41 31 80 B8 E2 89 B8 72 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 513 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF +Result: + 13 8E FA 8E F0 D2 3B DF 15 53 CE 3C 5A A9 C9 FD + 2F B2 4B D4 3B 2A B8 23 31 4A 65 A1 6D 33 0C BE +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 768 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 +Result: + 30 70 95 DF 4A 0D F7 92 E1 AB 68 6F F6 5C 16 E1 + F6 2B B3 60 41 DE 88 EC 26 D4 83 5F 36 04 7F 4F +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + B8 3D 70 87 C9 0C 90 73 D5 D6 53 13 0F 51 30 03 + A4 B2 EF 94 5E EA A0 45 67 A4 B8 B0 BD CC 16 40 +-------------------------------- + +:Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 81 17 AF 41 CA CC 2C 11 EB 0D 69 DE D0 29 5A 40 + 89 ED 71 74 +-------------------------------- + +:Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 0B B7 6E 27 30 70 FE 54 FF 5A 60 4C 93 E3 01 98 + 50 02 03 D5 D2 F4 E8 0E 1E 91 58 6B +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + D5 0E 55 EB 01 B8 B5 B6 4A AE BA 67 3C 27 6A 0D + 49 81 60 7D DB 20 9B 83 A5 E0 E2 61 CC 98 30 34 +-------------------------------- + +:Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 94 75 66 DB 59 42 47 30 59 82 82 48 35 06 04 AF + F9 BF 63 85 0E D5 DB 5A 88 35 62 C8 D8 07 2E 52 + 84 CF 20 C0 42 88 6B BD 00 58 F3 67 C4 25 C7 C4 +-------------------------------- + +:Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + BA 2E 95 F7 0D C3 3F D6 87 7C BC 1E 59 A6 DC 8A + DD CA 79 96 8F 9B 4A 5A 3A 3A A9 34 CF 55 3D CF + ED BE F2 AC E1 4E AF B7 56 B0 BA CE 0D 6D 99 9E + 49 CF CF 53 B2 96 B9 2C A0 1D FD 6B 39 FE A6 43 +-------------------------------- + +:Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 9B 25 9E 53 87 80 E7 58 99 68 73 20 CC 83 CD 83 + 94 F0 35 09 91 4F C2 0E 2A EE A9 D7 5B E0 46 64 + 2C E3 C2 E3 3F B7 27 52 00 C5 E3 7B C3 D6 9D 14 + E9 C0 8E 1F 3B BA AB 51 9D D2 CA C6 EB 40 14 CB + 73 D4 90 34 FB 31 4E 20 C8 42 4E 30 07 E2 21 92 + 60 7F 03 93 64 3F C6 F4 3F 49 31 B7 0C 4A 12 1C + 4C 1F 94 AD 6D 7F 99 DE 8F DF C7 0E 7A 57 A0 D5 + 2A 29 8A 01 8E C0 87 D5 DC F7 E5 58 8B 2C AF E8 +-------------------------------- + +:Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 8E A5 9F F5 ED 8A 15 09 64 C4 BD 2D E7 D5 16 B7 + EF 1A C7 2D C5 11 90 BC 1F AB 61 5C 95 3A 21 2D + 89 +-------------------------------- + +:Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + BB 2C 5E 05 FF E9 C6 4E 44 29 D2 04 F9 70 EB 70 + A9 FA 2C A8 E0 75 CB 88 19 FA D2 33 81 03 35 FE + B9 D9 04 EB E9 7A 33 54 98 4F EF 3B 11 D2 E5 A7 + 62 D3 45 7F 47 1E B9 3B 39 B8 65 C3 D2 FA C8 A6 + 72 +-------------------------------- + +:Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + B1 9B 36 6A 5C 7C 1B 19 81 6C 3A B8 AB 48 FB 9C + 3C 7A 96 31 5E FC 6C B4 B8 C3 7D 14 6A C5 76 88 + CA 56 73 2C 87 A8 9A E9 7C 84 C1 C1 71 0B 4F C2 + 25 24 C7 68 1F 55 98 E3 88 2B 23 FA DF 2B DC DB + CA B9 2D F7 96 9A 3B A3 CB 9D BE 53 86 7F E0 3C + E5 8D B5 BB 27 C0 BA 25 B4 0A 6D 4D CA 6A 39 16 + F5 69 23 75 4A 68 79 90 6A 9D 85 03 8A 9E 74 7D + 20 1A B4 06 03 B4 2F 3D 7A C6 9F 56 38 42 04 30 + 26 +-------------------------------- + +:Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + AD 90 36 7D BA 0C B3 82 4E 42 3E 1E 22 16 B0 23 + D7 F1 E8 00 82 5D 6B 61 8F B5 26 A9 89 AD 1A 02 + 6E 45 BF 29 51 B6 98 F6 B0 FD E1 14 B3 93 93 0F + 79 13 E1 76 DE B8 ED 98 C8 BC 7A 2B 66 60 18 96 + AC 96 58 DC DC 93 8B 5E 84 52 E2 11 58 2D 97 ED + A4 EC A5 F1 12 36 42 3E F1 8B 11 51 43 4C 6C C7 + 46 79 77 BA 59 25 F3 C5 20 80 4B 1A AC 5C 04 EA + 94 C7 4A A8 06 73 3F C5 85 E7 4B D4 2D D8 18 04 + 58 46 F1 0C A3 6E 75 6A DE F7 FF B6 D2 6D 4B DF + 25 FD C0 60 04 38 8D DC 9E 19 07 52 98 5A CB 84 + 1A 94 7F C2 1F 89 B4 C1 BC EF 79 74 5C 48 A5 F0 + AC 76 8A B4 09 2B 32 F7 59 D2 05 E8 6D FA 90 3D + AE 2C 79 3C B7 3C A3 91 F1 F0 D1 EF 20 79 55 FF + 43 75 58 A2 9A 62 8F 3B 69 32 10 3B 5B 05 4F 30 + 86 BC 5F 16 DB 1F 11 9F F9 BA B7 46 5B 27 60 BE + 0F FC F3 4F B3 83 AD 64 4B A3 1B 52 4D 7C 6F 3F + F7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F +Result: + FD 03 D8 00 EE E2 C4 70 22 E7 EF EA E6 3B 62 F3 + 99 E3 2D 85 27 77 27 C8 A3 20 E3 C8 9F DC 73 BE +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 80 01 E5 D6 34 F5 18 69 15 73 29 FB 47 55 E1 97 + 04 A8 00 97 D0 C7 88 2B 86 00 5C 51 CB 8B EC CF +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 12 A3 24 5F 2E F8 87 99 B9 E2 04 80 21 65 DC 75 + FF 36 5B E4 F8 64 FE 1D AC 0D 47 B6 F2 5B D5 46 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 + FF +Result: + EB D8 0E E1 F1 74 50 59 16 8E 24 54 B5 7C 0F 02 + C6 89 A0 2F 94 C0 FD 36 1A A1 E8 AD 66 FE 02 FE +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 0 bits, data = 'incrementing' + +Message data: + (none) +Result: + D3 F7 26 3A 09 83 7F 4C E5 C8 EF 70 A5 DD FF AC + 7B 92 D6 C2 AC E5 A1 22 65 BD 5B 59 32 60 A3 FF + 20 D8 B4 B4 C5 49 4E 94 54 48 B3 7A BB 1F C5 26 + F6 B4 60 89 20 8F DE 93 8D 7F 23 72 4C 4B DF B7 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1 bits, data = 'incrementing' + +Message data: + FF +Result: + 6E 69 B5 AC 4A 5F 56 87 18 D8 7A 9C EE E8 38 44 + 7E 3A 12 D9 C0 1B C9 6E 2E B6 11 3E F8 8D B1 DF + FD 95 53 E9 5D 75 5D 38 C3 BD 58 70 F8 45 A3 C2 + 42 7E 29 6C 95 13 B1 3B D6 3C 89 1E 64 33 4A 0D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2 bits, data = 'incrementing' + +Message data: + FF +Result: + 9D AA 7F 12 99 73 C9 AB C8 AB A7 1E 4F C0 26 4F + 11 D0 74 C6 03 E9 11 16 90 ED 24 78 C9 8D 31 21 + 1C 71 5A D0 9B E3 85 8C 16 14 1E 50 C8 1C 31 70 + 4B C6 0D AA 0C 6F F6 95 01 FC 26 D7 0D D0 EC BB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 3 bits, data = 'incrementing' + +Message data: + FF +Result: + 37 45 BD A3 9E FF F8 54 2E D1 D1 8E AB E8 EA D5 + E7 8A B0 12 E9 85 39 90 40 74 86 DA E0 07 D5 5A + 64 FB 9E A9 3F F2 EF 2D F5 A5 40 12 75 97 B6 D1 + F2 37 F1 29 42 59 01 A2 BA 06 21 83 CA 60 7D 49 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4 bits, data = 'incrementing' + +Message data: + FF +Result: + 1B CB 78 F2 67 E7 8D AE 31 83 F1 AB 1C 06 DF 43 + F4 EC 54 01 0C 99 0F B0 3C EB 8E 16 CA 81 21 6F + 0A 80 1B ED 97 24 15 9B 82 4E 00 F7 3A 8F B1 A3 + 9E 79 F0 5F EA 17 EB 8E 4A 27 54 C1 1B 22 49 BC +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 5 bits, data = 'incrementing' + +Message data: + FF +Result: + A2 13 59 7C AF 90 AD 52 14 A9 F5 4E 87 01 6F 42 + 08 57 DB AB D4 08 B5 F9 3E 72 A6 E1 44 2F 0C 70 + 96 44 9A A5 E2 18 6B BD ED 4C 74 10 C5 6D 1E E0 + 36 69 98 30 5F E0 20 1C 23 10 05 4E 14 C5 FD DD +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 6 bits, data = 'incrementing' + +Message data: + FF +Result: + 75 58 56 1A C3 7A 5C 14 64 84 80 03 08 CA 02 E2 + 91 F4 D3 8B 0F 51 EB 2D 4E 3D 93 D5 E6 66 D3 3F + F6 43 BA 4C DF DB 9E 10 04 3F F8 A9 CA 7B 8A 4D + 33 58 17 26 35 8A 1F AA 30 AE D7 E3 8C DE 57 89 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 7 bits, data = 'incrementing' + +Message data: + FF +Result: + D9 55 C5 16 DA BA 0B 47 F0 81 DA E6 25 58 FF 80 + E9 BC 42 1D 37 A6 DA D2 07 41 2C F0 C8 F2 A3 D3 + 12 6F 67 77 DF 70 6B 18 9C E3 52 BD 48 88 89 87 + E4 85 CC A5 00 13 20 C7 9C 3E 88 79 6B FC 45 72 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8 bits, data = 'incrementing' + +Message data: + FF +Result: + 8F CA 8D 27 05 F9 9A 56 90 43 08 A4 00 4C 64 EF + B6 68 81 8B 58 B0 89 5B F7 29 6A 2C 5A 54 F9 30 + 14 83 D6 22 C4 A5 AE C8 55 AC 30 08 7E 1E B0 E8 + 39 40 90 6E 7B 05 5D 70 D4 46 C8 D2 85 F2 7F 01 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 9 bits, data = 'incrementing' + +Message data: + FF FE +Result: + C3 57 96 87 4A BB 1B 50 57 DF 78 25 F0 CD 7A ED + 1E E5 6C F0 2E D3 FB 43 75 91 0A 75 79 6C 66 F5 + 4A E4 CC 4A E9 AC E3 7B DB 36 D3 0C C8 9A DF 93 + 4E 48 C1 7C B1 EE 8C E5 D6 0A EA EE 6D 0C 8D 31 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 10 bits, data = 'incrementing' + +Message data: + FF FE +Result: + 6E 00 6F AE F0 FA E5 34 73 EE D4 DE 13 73 07 7E + B2 33 C5 2E 1F 25 EF 75 27 30 90 3F 20 29 D4 A6 + D2 73 B5 7C 70 5D 06 7C 5A BE B1 62 DD 8B 0E 62 + F9 F7 7B 57 0D 80 C8 DD 86 73 97 14 7B 2A 2E C7 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 32 bits, data = 'incrementing' + +Message data: + FF FE FD FC +Result: + 9D 1A 1E 9C CE F9 27 25 55 F2 01 47 97 81 A1 CD + AE 7E 27 38 15 0B 17 7A 9A E9 66 54 E0 B1 3C E4 + F8 D9 01 AC 41 52 DC B1 A5 53 6B 42 68 92 04 F8 + 45 88 4D E6 8B 81 98 97 B3 A8 08 CF 57 B3 AC 36 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 64 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 +Result: + 75 B1 65 4B 2D D1 16 63 82 43 8B 06 7F 91 54 80 + BC 6D 6F 9B 06 0F 2F 45 D4 55 89 C0 C2 2D BF 64 + 85 D1 D2 EC 3E 0E FA 73 CB 52 40 0C E7 EE ED 64 + E1 AD DA F9 A7 45 21 C7 ED E9 A7 19 33 92 B7 24 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 128 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 +Result: + 51 B5 20 9C 03 25 C6 19 4E 89 14 FA BD 4F B0 25 + 06 7D DB C3 49 ED EF 9A 08 8E E7 27 0F FE 36 37 + 38 A5 46 C3 52 20 92 EE E1 A9 D2 8A 81 1D 2F 60 + 25 5A B8 FA 5F 5F 73 A4 8E 7B 0A 3F 80 96 04 61 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 192 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 +Result: + 66 D5 0D 0C D8 3C B5 6C 14 58 38 1C 08 A5 D7 44 + 40 97 DE C7 71 C0 ED 45 11 A3 78 9D 08 68 7E 82 + 4E EE 37 10 62 64 50 E4 71 22 1D FC 62 1D 0A C7 + 0F 55 42 CA A4 97 70 FD 2A F0 01 44 A0 16 4E 03 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 255 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + AE 0B 9E B2 D5 38 46 91 9F 8E A1 42 F5 D8 05 D5 + 4C 6E E3 57 40 E8 C9 29 B4 15 36 EF 18 43 DE F9 + E3 D1 89 56 91 92 F6 8A 1A A9 2F CD CF 98 BA 8C + B6 41 CD 8F 49 F0 62 9F 57 3B 93 52 9B 9B B8 A8 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 256 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + 5D 10 E1 EE 2D DE 01 71 DF 56 B7 4A E0 DD 1A A2 + A1 B5 9A AD 22 F7 58 2C F7 38 8C 2B 4C 7D FA 75 + 13 D5 32 C4 55 77 D9 9B EB 72 FB F3 C0 A3 2B 80 + AF DD A0 B4 7F A2 A4 58 52 F9 84 43 26 42 D0 18 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 257 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF +Result: + 4C 81 4B 21 AC 9B 9D 07 9C 75 3F E1 E6 D2 5E B5 + D6 2E C8 5D 56 67 91 F2 EE 57 42 2D 78 B4 73 A2 + EB 91 8C 3A 7A 14 4D 7F 56 2C 65 59 A8 7A C8 B4 + F4 21 6D A5 FC B6 CA 46 68 09 54 06 08 ED AE 85 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 384 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 +Result: + 07 9B C0 46 45 83 9C 2C 48 B1 2B 6F D5 10 37 FD + DB C6 99 6C 32 4B 87 84 F7 FB A0 E8 98 99 2A 51 + 62 F4 22 75 03 41 3F A2 A2 E8 BB 48 5C 64 F4 BB + 30 DB 46 99 A6 CA 8C 23 8F 7B 38 D7 02 EE 6F 06 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 511 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + 88 95 AF 9B D1 69 0B B3 9A A3 4A D9 AA 2D 07 90 + 92 69 D3 8F B5 54 27 F3 96 48 BB F8 68 14 EC B3 + 7B F7 A5 39 45 7B 38 47 11 23 F4 14 4B A3 F7 30 + 40 AD 39 5F B0 2A 34 22 16 8D 07 8F E2 CB 82 D0 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 512 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + 0F C4 2E 10 0B 2C D0 B0 C6 9F 39 38 3F 9D 2D 17 + AF 6C F7 4E 2A A8 D4 E2 D9 1C BF 94 A5 99 35 A3 + 12 3B 7F 92 50 F9 82 22 4B F0 C3 E1 90 BE 10 AB + 41 AD D8 C1 E3 5C BE C4 B1 B3 C3 5D BB A5 86 9C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 513 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF +Result: + 93 87 FD 70 1E 55 FE 72 D5 22 E4 67 3C 1F B6 1B + 0B 1F 81 06 86 1E 02 F7 7F D2 F4 5D D2 2B 51 42 + 0F A9 92 85 F2 2D C4 8C B5 7C E1 7F F0 16 90 7C + 74 89 59 5F F9 B9 A5 6E C9 03 4F D3 09 2E 5B 61 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 768 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 +Result: + AB 06 30 B6 EC 56 3E 8F 92 5D AD EA 42 63 19 05 + A9 CA 84 5B CE 09 6D B0 6C 6B 94 53 1F 99 78 13 + 5B D4 92 D1 B4 B1 8A AA FA 42 17 76 33 49 9B D6 + BC 41 27 E0 6E EB 44 7A D7 B2 2D 2B EB CE DF A0 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + B9 2A 3E C0 85 E2 EC 45 AA 48 AA 31 D4 2E 7F 78 + 6F 32 72 FF F3 BE 78 2B 15 BB 3A 0A 5C C7 78 86 + 65 51 40 75 9C 11 CB B7 87 DB ED 9E A3 5D 68 2D + F7 82 F5 CF CB 84 93 CB 05 5A 01 FD 38 32 F1 B8 +-------------------------------- + +:Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 65 A3 8C AE 89 BA 36 1F 74 3F 59 D3 61 23 FF 76 + D5 DA 9B 49 +-------------------------------- + +:Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 97 B6 91 C4 E4 F5 C3 A9 8A D2 2D 73 A6 0A 1D 29 + AF 99 10 06 05 3C 15 25 E4 B6 F9 11 +-------------------------------- + +:Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 9F A2 41 15 FF 41 C8 47 EB 69 40 BF 2E 8B CC C4 + 09 7B 57 F7 F8 F0 02 87 A8 AB 8A D7 75 80 AF 80 +-------------------------------- + +:Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + E4 6B CB 15 4E FD B0 F2 DC 30 CB 6E B0 CC 52 52 + F1 35 C8 DB 65 9C 34 22 99 0F 4D 9D B6 94 B1 B8 + 92 DD 74 9B A2 18 34 33 53 64 59 74 D9 13 A4 A0 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 0F 01 9E 7C 18 49 16 7C EC B9 A0 D8 F1 B0 0C CD + 5B 14 15 9C 5A AE E4 49 DA B5 5A 1B C6 C8 51 03 + E8 37 84 54 91 2E 46 AF 63 06 79 50 F8 63 04 3C + CF A3 69 98 87 A2 57 73 37 CA A6 65 31 BD BF 9E +-------------------------------- + +:Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 58 E1 53 9D A4 28 0D C8 CF 6A FC 25 66 C4 18 D7 + 42 AF A6 05 A6 64 1F 58 F2 38 39 46 97 68 FF D7 + CC 2D ED AD C6 2F 7B 6E B0 76 AD 53 E2 4D CF 23 + 5F 65 58 36 E5 32 1D B8 85 6B 3E 64 E4 42 88 B0 + 09 63 04 2C FD 4D C0 0F 5D 30 A3 01 6C 09 B5 4A + 0E 46 F9 0B 5D 9A 9B 72 2F A2 F6 59 96 2A CF F2 + 61 28 7D 3A CA 32 49 7F 76 E6 A1 59 C6 D3 B7 7E + 49 DC EC 3F E4 2B 69 1D 6B 7F EE 25 DD 25 70 45 +-------------------------------- + +:Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + B2 8F 0E 26 15 87 35 6F 75 28 30 1C EE 8D 35 95 + FD C7 C1 82 94 EC 5D 76 4D 3C 29 57 78 E1 BA DC + B9 +-------------------------------- + +:Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + C3 12 CE 6C C6 44 A6 59 D3 5F 5A 84 AA CC 98 8B + 5F 12 5E 73 3E 32 C3 55 14 61 51 38 21 54 59 5A + EE 59 32 4C 5B 00 F4 64 2D 57 F5 C4 0B 37 F4 33 + 87 4F 96 81 6C A5 6E 72 54 01 29 B0 7E 76 1C E1 + CE +-------------------------------- + +:Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 3D 64 CF 00 ED 27 34 2B A6 10 5F 27 8B 16 36 9F + 91 F0 42 32 1B FD E6 A2 38 A8 5C 70 41 CC E5 4A + 43 86 C9 6E B1 6C 74 2B 99 29 1C EA 7F 30 6C AA + FA C3 05 96 CC AA D0 AF DD 58 EB EA 51 3D 86 86 + 9E 63 53 43 6C A2 5F 28 5A 54 A3 DF 5C 3A CD B4 + F1 BD E4 68 B1 C7 43 07 5D 43 78 6D D5 7D D1 D2 + 06 43 FF A7 45 98 91 28 8F 47 70 9C AE 40 CF 8F + 98 08 B3 F2 55 7D 8D 70 73 09 28 1A 37 4D 31 12 + 96 +-------------------------------- + +:Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 47 40 93 FC CB 0A 75 36 C8 BA 29 9E 59 AD 26 20 + 26 08 75 3D 36 64 8D A4 25 2B A9 58 45 06 4C 2B + 4E 60 B2 F4 85 F3 3D 3C EE 69 37 ED C5 76 5C 1F + A1 CC D8 7B 52 02 AA 2B 21 DA 02 C6 C6 0F 27 72 + 09 D6 00 C4 F5 9B 3D 6D DE 2A 93 12 3E D1 3B 72 + D0 EA 1C A6 48 8C E4 FB 08 5A 76 49 5D 9B 60 98 + 5E 9E B8 B8 21 BB B5 3C 78 C2 4B 1E 49 B5 B2 34 + BF 82 7C B7 2E 8E 7D 4A 63 9E 97 AF 1B FD 9F C3 + C4 5B 42 0E 49 9A 0D 5E 88 42 9D 1A 4E 0C 40 DD + 0C D0 6D 1E 3F 11 4E 0B FD E7 76 B4 C3 E8 C5 F6 + E6 04 25 18 32 72 24 97 65 E2 5D 36 9A A3 48 B9 + AC 13 99 CF EA D7 B0 5E 1E 97 8E CB 94 33 92 4F + 9C 65 19 12 F7 28 70 27 2A E5 4A 98 59 67 93 98 + 95 03 45 D9 34 48 E9 B0 43 0A 9C 6C 72 45 6A 25 + 91 83 3B B8 4E 4C 39 F1 F6 EB 87 DC D3 7C E6 B9 + 1D 0A FF A8 2F 71 A0 AF 48 EE 0E 68 9E E0 63 DA + C2 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F +Result: + 79 F9 CB 25 8B DC 5D BE 7C 78 6C 37 95 CF D2 D9 + 2D F8 7E 98 D6 97 E5 D7 3C 6C 0C 2D 43 4E 43 85 + EF 8B 09 18 BC 48 C7 23 28 26 6C 74 1C 1D 7B 46 + 5F AD C6 BC 3C AC 7C 89 D5 DB 7B 66 97 A3 AD CD +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 08 54 3E 94 68 32 70 AA 6E 92 D0 6F 16 26 8E 22 + BB C9 D1 BA 43 73 05 35 89 64 1C 07 E5 FF B4 16 + CF 5F EE 9B 72 BF E8 65 48 36 2F E6 1F 89 00 6B + 89 E2 4F 53 2F CF DE 35 F9 A6 C2 46 5C 3D 9A 54 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 3E 70 CC B4 B0 B0 B5 65 27 D2 22 ED E2 FF 8F C2 + 35 18 4B 01 40 74 F1 A0 9F 2F DB 59 7E 09 5D 6B + 94 54 15 53 BF 30 59 C4 67 2F 43 1D 39 97 42 BB + 8D 0F CD 9C FD 94 29 2E 4C D0 52 3F E3 35 DF 77 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 + FF +Result: + 4C 10 93 12 B6 D6 74 50 76 DA EF 88 43 03 24 ED + BC 2E 6F 8E 99 FF 70 F1 11 D2 60 41 66 3B 04 49 + 9B 08 3F 66 19 D2 BE DD 0F 47 F1 BD B7 76 3B 91 + AA 84 CE C7 3F AF D0 98 BE 52 90 5B E9 C4 F7 AE +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'incrementing' + +Message data: + (none) +Result: + 7B C3 CE 31 C0 35 DF 3C 7A 7D 55 9B C9 D9 45 4F + 87 9F 48 49 7C C3 9E 6D 14 E8 19 04 98 45 5F 39 + 6F 45 59 04 05 C4 A1 5B D0 AB 29 F5 46 7D 91 32 + 80 2F 43 54 37 6E E8 64 AD 9F 20 0E 39 A3 D0 9B + 9A D0 6E 9D 0F 65 6C F9 1E D9 DE AC 13 A7 A6 7A + 82 AB 98 3F 52 13 31 29 CA C2 A4 DC 13 FD 29 C3 + 6C A6 C7 2D 6D CC 6C 82 C6 67 97 F6 B7 60 7C B0 + E0 F9 00 6A 27 B8 3B 60 C5 9E 4B A1 8D E2 33 E0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'incrementing' + +Message data: + FF +Result: + 7A 02 04 48 B7 6D 52 9C 8E 65 D8 F9 E8 07 DB EA + 56 44 47 35 9E 18 C8 F8 2E 46 F6 66 DB 69 88 0C + EB D7 AA 3E 85 03 1B D8 65 4E 43 B9 F1 9A 39 A7 + 58 C1 CD 14 F2 1A 0A BB 71 10 B5 56 C3 94 4B 51 + 6E 71 EC 1A 4F F9 72 69 56 5B F4 40 34 83 96 58 + D6 AD 2A 97 44 24 2C 19 E5 13 A6 B3 62 70 00 46 + B8 70 A3 25 E3 BB EE C3 DE FD 85 FF 06 CE 73 A6 + 9E 0B 68 90 2D 67 54 C6 24 03 47 DA 92 F4 29 1E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'incrementing' + +Message data: + FF +Result: + 8B EB F3 30 C1 36 16 8F 4A 16 46 36 32 30 1E BE + 45 DF B2 79 78 6F 82 B9 DE 31 1B 69 03 45 F9 01 + B1 52 8F 8C 8A F2 22 1E F3 30 51 14 D9 F6 8C CD + A4 B8 42 AF 8B E9 B6 5C A8 23 B4 92 31 B8 EC A0 + 46 98 4B BF 82 64 A6 C8 19 87 89 6B 04 D0 D8 92 + E6 DF BB 08 19 DB 71 BC 00 6B 5C 74 DB 5C 53 29 + 54 F0 DE 22 88 26 5B C9 BA 66 44 16 54 FB 29 8D + C6 46 AD 0D 03 80 26 E8 9B DD 91 F7 C7 5E 69 BA +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'incrementing' + +Message data: + FF +Result: + F2 89 AA 9B 6F 60 4B DD 66 B7 81 BA 80 28 CE 27 + F5 00 04 D7 0B 48 F9 3A 09 B8 52 D5 15 7C 9C 41 + F6 86 9F FE 6D FA 8E 9D 91 51 5E 22 30 19 18 87 + DD 0B 91 12 00 09 E1 A8 61 00 46 E4 74 34 8A 1F + 1D 7B 44 36 28 3F 55 32 10 D1 F6 CA AB 13 99 FC + 81 AC 8C FA F8 5F FD B8 35 2A 1C 78 76 03 FD 07 + 88 58 2A 2C 8A 31 64 A2 DF 61 87 C4 13 AE 76 83 + B0 54 62 5C CE E0 EC 6B 9A 9F 79 A3 8B 4C EE BE +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'incrementing' + +Message data: + FF +Result: + 41 3F AC 75 E4 C2 C7 7F 4C B1 DC 48 EC CC CC 07 + 2E 36 73 8B BA 67 9D 5B 81 BC 11 19 88 15 05 18 + A5 DA 6B 17 0F 8F FA 45 50 EE 8D 7A 18 5F 4D 33 + C5 15 20 66 90 7D 31 8A E5 A1 8B 42 90 94 92 20 + 3E 1A 63 EA 86 7C ED B9 97 F2 A6 AD DA 27 C5 5B + 37 E1 23 98 78 6C 74 4D 54 BA 65 A0 8D 1B 5B 6C + 9C 00 34 20 25 B3 EC 83 F2 B3 F7 51 31 83 9C 73 + 63 A9 0D 8C 1B F2 35 02 7B 50 4E 03 77 64 D3 AF +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'incrementing' + +Message data: + FF +Result: + 2D C5 A7 16 D3 2C 6A E0 6F D8 46 99 9D D4 50 E2 + FE 5E 6D E9 62 A6 C8 4B 22 57 D7 60 E9 88 C3 5B + AF C4 9B 3E 71 14 A3 51 6F E6 28 78 65 3B 63 7E + 4B 0E 8D 95 62 52 C4 21 E8 11 33 5C 76 84 24 B4 + 79 30 5A FD 78 3E 47 DE 15 8D 60 9B DA 26 66 DE + 80 5E 2B 21 24 A2 21 95 EB 4D AB B4 63 7B 4B 17 + 27 97 00 FF 16 07 E8 FD 32 FE D0 BE 5A C7 28 C5 + DF CC 63 A4 90 99 64 1B 58 2A D7 54 54 A6 8B C0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'incrementing' + +Message data: + FF +Result: + 8F BF E0 44 4D 76 FD 02 EF 78 D5 1E 32 60 66 91 + 4F 08 B8 FE 4B 6F 24 1D C6 72 85 51 FD A3 A8 B4 + 8D 02 03 94 BF A0 24 8B 58 B2 41 43 CD 53 4F B3 + 4F 37 0A 63 7B 81 B5 E4 E9 B6 C7 00 BF 4C 67 20 + 46 EB F9 D6 9D 12 5D 78 7B C6 05 B2 41 83 5D EF + 0F 53 F3 21 8C 00 10 2F BE 45 16 50 E1 1F A0 08 + AC 3A 74 69 6C EE B8 7D 37 F9 4D 43 50 FB 4E 44 + F4 53 1E 85 9B 3E 1E C3 34 39 1A FE A0 F6 94 4D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'incrementing' + +Message data: + FF +Result: + 82 F3 AB E3 61 E2 A2 4C B1 00 F4 BD 1B 56 39 6B + 28 8F 85 F6 F4 50 91 CE 1C 4E E6 14 27 34 6C 45 + 14 A5 19 11 D8 ED 04 4C AC 67 A2 25 77 E5 1E 55 + C0 A3 51 D0 FC 60 71 25 57 A5 44 C1 11 3E CF 9C + 4B 94 D2 80 C8 BD 69 C7 21 CC 41 70 D5 DA 23 33 + AB 2E 06 E2 13 24 C3 8D 06 96 D6 B4 47 75 A0 7C + 15 FD 3E 7A 3D 27 77 E3 09 64 93 4B 6A FD 95 44 + C6 28 A5 FB 20 3B 69 78 ED 0F 0D 58 63 0B 46 E0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'incrementing' + +Message data: + FF +Result: + 2F 2E 87 C1 4F 43 11 28 E2 69 B2 3B 45 BE B3 64 + B6 37 84 53 17 7C 44 1B B6 AF 57 8A 86 FC 0F C9 + AD BE 93 5F 8E 73 B0 0E 04 E9 AF 05 4E 3C B4 87 + E8 74 2D 76 79 CF 6A 84 26 1F 6B D7 C8 BC 1D 71 + D5 0A 97 D9 22 70 1C 6E F4 C2 9C 52 76 4E CC 6A + EC 45 57 CC 4C 51 16 9A CF 0A 4B FA B4 57 5D E9 + CB 81 64 4A E6 86 8B 49 98 69 06 57 13 5A 6C C1 + EC FE 6C 8E 1F 9F A7 29 E3 FF 5E E5 5D 9C E7 78 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'incrementing' + +Message data: + FF FE +Result: + 97 8D F6 97 8A 28 9E F5 C6 22 4B 43 C0 7A 7A 8F + 63 66 E1 4C E3 B6 A2 59 EB B1 3A 82 CA 07 4E 12 + 31 A7 51 36 28 18 BE 05 CF A3 E6 E0 0D 85 15 B3 + CA 14 83 96 83 F6 77 BB 77 80 8E A4 0E C9 ED 79 + A8 4B 66 21 A0 30 BD A4 21 18 89 E7 2A F2 1B ED + 35 04 18 58 02 F1 92 53 E2 FF 0D F0 CC 01 86 6C + F0 F3 2D 94 C9 BE D2 E1 21 4C 6D D7 8D 2B 00 EA + F1 88 BE 93 B7 40 C3 C7 AD B0 7D 05 20 92 DC 80 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'incrementing' + +Message data: + FF FE +Result: + CF 3A B8 AC B1 D5 FA D0 97 A6 50 AB B8 BA ED 35 + 77 2B 88 80 5C E7 84 D0 FE DC 39 F9 E2 F4 73 20 + 63 A2 41 67 D5 10 31 30 69 A3 DA 59 73 93 DC 87 + 3B 72 68 20 44 52 BE 46 D8 01 A6 49 E0 47 1C E1 + 13 01 39 E3 5C 83 4C A4 AC 68 E3 1A CC DE 61 CB + EB EB CB 95 EE A4 7B 87 8A 8E FB FD 28 FB 70 B1 + BE 8B 17 77 D0 93 1A 21 8F 53 E0 69 6D 88 52 AD + C0 B5 76 FC 95 24 CA 49 8B 45 D3 EA 12 CB 29 82 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'incrementing' + +Message data: + FF FE FD FC +Result: + 81 32 79 E7 6E 86 55 5B 38 DD F0 18 DC FB 73 EA + FC D8 A1 B4 51 54 E3 C7 96 B5 09 7D 0A 0B CB 6B + 01 EA 49 8E D4 F3 75 EC EC 5B 9D 57 60 24 FA 9D + 2F E1 48 95 CB F5 3E EC 31 10 82 81 84 F7 02 12 + 7F 39 67 43 DD 55 16 82 F5 28 94 A9 80 C5 0A AA + D3 9F D3 AC E8 22 85 73 23 88 2E F8 6C BF 0A 65 + 61 7E 23 6C 67 4D C1 79 81 A9 7B 74 55 89 F3 40 + AC 30 D4 5A 38 B2 3F 82 1E 5A BB FC 2A 9D 74 02 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 +Result: + B0 9F DF 75 28 A1 A4 F2 DD 98 BC FD F7 C2 E0 43 + 79 95 5A 97 E5 A5 84 E1 4D 78 97 23 80 29 57 BB + FC 9C 41 8A 6D 16 9E 1B D3 EE 44 03 06 3E 8A F1 + CF F9 94 45 B9 78 58 3E AC 53 67 C0 CB 28 18 BF + 6D B4 FB D8 39 24 5D 6D D8 AE 95 DA DC 61 BC C8 + 88 8E FE BB 94 FB BE C7 51 3C 91 4F 1E 2D 54 F7 + 60 28 4B 86 51 60 AF 74 7E C6 57 77 94 31 A8 8B + 60 1C 73 1F 5C 16 34 8D 48 67 AC F4 07 B6 AC 50 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 +Result: + 33 1C 6F 61 70 46 58 6B 48 9E 96 C9 D8 47 9A 74 + 14 29 CE 3A 26 59 BE F6 D1 FA 8F B4 72 9D 17 78 + DE 6F C0 52 CF ED 15 77 BA B8 55 A0 DF 3C 97 CE + A6 4B CB FF 11 5A 5A 4C B8 FB 63 3D AB 2B F6 7B + CD 16 62 B6 7C C9 F9 3E D5 1C 35 62 FE A2 79 5B + F3 C4 DE A8 D6 DE 1D 54 3E F7 27 05 78 6F 27 74 + 64 AD DE 1D C8 70 CD 46 1A D1 42 F3 82 71 8C AE + 25 EC 38 5B B9 CA 1A FB 83 42 2B C4 07 59 AC 2E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 +Result: + 82 42 AF DA B4 1D C6 59 44 34 25 88 05 63 12 66 + 47 7F DA 05 D6 3C 6D F2 CB B8 DA E1 EF 54 22 1F + 20 C4 9A CB E2 DB 31 79 37 30 EE 29 3A 71 75 EA + DA 85 7D 4C 35 FB A7 A2 EF D9 92 3B C4 D6 7B D3 + D2 AA E3 D6 94 14 FE 53 63 AA 27 9F 44 E8 67 3E + C6 75 E8 2B 6A BE 0E 08 36 62 13 08 25 55 91 D5 + AD 53 1A F7 E6 46 07 F9 52 F8 3A A4 55 12 4D E3 + 2E 97 00 7A D4 FD 05 69 54 29 79 17 4F 8C 17 7A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + 2E 88 AA 79 1D 1B 93 F7 1E F5 53 58 49 D9 9F 95 + 6E FC 38 0D DC 42 CF 46 3A 65 F4 79 DC AC CD A8 + 6A BE 0D B9 3F 95 A5 81 8C EF C1 F3 45 7F 2B 12 + 51 EE 52 96 4F 2D 0B 71 06 CF 99 7F 1B 08 87 E3 + 2E 42 8D D6 22 E5 0A 8F 07 D7 84 87 69 8C BB 22 + 68 F8 C4 86 32 FC B5 0C 58 1C 6E 11 C9 0C 20 B8 + DD 45 04 14 E1 AF 3F 48 2F 8A 73 D8 CB D6 7E A5 + 2C 01 CA CB 16 62 EC 66 2E 7C FC 84 07 D7 6A E4 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 +Result: + F8 E9 27 0E 6D D7 BA 65 14 9B 4E 60 59 BD F5 D7 + 56 B5 7A 31 25 17 30 D7 E0 35 03 C6 1C 68 FA CA + 41 1B 36 A8 6E 52 F6 2D 6E D8 16 F0 6F 59 69 82 + 30 84 0E 83 1D C2 17 D0 22 41 B3 D8 A9 1F DF 31 + 63 57 B8 80 1D C6 75 D7 00 8F 7E 3F B3 C0 89 63 + 83 C5 CB B6 B6 37 21 51 A0 3D 1B 14 DC 8E D4 41 + 6B EC ED 25 D7 00 97 0F D5 18 E6 34 DA 56 EE 4B + E1 FF 6A DC 6D 55 EC 14 B7 91 A3 F6 F4 43 AB 4A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF +Result: + 3F 8A 72 9D B3 0F 2B 56 66 91 94 3A FC 30 FA 90 + D0 01 11 6A 4F 76 91 39 61 DB 7C 13 42 E7 44 66 + 98 03 36 72 73 ED A8 47 4B 09 35 D4 13 1B D4 6C + 21 9C DB 5A BE 04 99 A6 DD 60 04 FA CE BB F9 49 + 06 B4 5D C5 60 A4 D1 BD BA 2A 41 AE CD 33 8F C5 + 99 2C 9A 7E D2 CF 4C 10 68 89 D1 DB 11 1E 43 AF + 89 F0 8B AF 61 7A 4A 2E 68 AD 92 9E 76 D7 68 6E + A8 06 A0 80 48 7A A3 FD 3D 1E 05 1F 3E 34 DD 3A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 +Result: + 92 52 CF B6 17 44 F1 F6 DB 82 5F 4B 72 31 15 FD + 0B CC 9A 62 85 71 DE F6 CE 35 4D BD 9A E1 7A 72 + D7 49 D8 CB F3 EF F0 AB 92 0C 44 86 AA CA A5 E6 + 28 FB FF D1 8C FE E1 A4 74 35 07 F2 58 93 52 99 + C5 9C 11 E6 D9 46 24 C7 BF 36 28 A7 0C 9C 06 5B + 2E 39 C8 65 76 FA 96 48 DD 3F 85 6D 06 00 73 B0 + D6 EE BC 81 5C 16 27 77 1D 8C C4 6B E2 D6 D5 29 + B8 3A 9A AD A9 A4 69 C3 1F 3F 09 10 ED 19 1F 1A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + 1D 6A 6D 9A 4A 6C 40 A6 70 AF 49 60 E4 DD 67 18 + 2D BF C4 23 3B FE 3E F7 36 D1 2B C3 0E B1 6D E9 + 10 DD 2A F0 F4 E9 E7 B6 58 02 D8 52 FE A7 56 66 + E3 1F D2 0E 60 33 FA 4E 16 8A DA 3F 60 FF 0A 2F + 0C 7A 65 CF 6B 26 BD 18 CD F1 2E 6A 86 22 64 86 + BF 0E D4 99 A2 1F DA B3 6C 66 CF 74 05 78 7D 2D + 3E F3 38 70 3C 18 01 8F 2F 07 C0 D9 2A CB CC 45 + B5 74 4F 9D 7C 46 06 95 5C 0D C2 CC 0C B1 67 42 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 +Result: + E4 18 ED 57 B7 6D 41 81 47 99 86 20 91 4A 97 EB + F1 E8 BC 64 EC 48 76 39 27 7C B7 13 08 A7 2D 3D + FE F9 C8 4D 4E 65 E6 E5 A9 20 25 6C 1E DE 8F 16 + C8 42 79 39 3B 11 BE 0C 90 0B 44 84 4E 09 25 17 + C6 9A 67 DB FA CE 75 CF 26 49 40 69 38 CD 71 B9 + EF CB C7 16 09 4C B8 A8 45 61 58 3B D8 9F F8 F1 + E6 BA A1 5B 7F 24 EF B7 F3 0A 5E 03 67 FD 50 4B + 36 3E 81 56 B8 39 23 F0 0A F9 91 F4 67 F7 62 67 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF +Result: + D5 D2 F4 70 17 4F E9 9A D1 41 1C 05 93 3A 46 72 + E2 8E 4F 28 2E 50 D9 71 DB ED F7 CC 21 3A 35 79 + 1E D7 29 57 D5 E9 98 C0 BD 57 8E D1 F1 3D 77 5B + 75 D6 78 AA A7 25 E3 03 80 26 F0 D6 4B 38 7F 53 + 63 1B AD 18 C1 57 D1 80 FA 96 C7 4D 38 FC 67 93 + 75 97 4F 1A 83 2B FC 3D 6B B9 06 6A 94 24 63 89 + 88 8D 75 11 5C A8 C9 9B BD 47 CF EF DD A1 02 BD + 63 64 BD 65 5F 7C 6D 9E 35 77 A4 FB 73 38 B8 79 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 +Result: + E9 51 CF 82 E0 50 31 E8 06 41 4B FC BB D8 D0 38 + 73 E9 07 41 FE B9 D1 09 9F 70 CB 39 12 F9 15 71 + C1 AE EE 9E 99 5B DF 46 EC 7F 70 B6 91 15 F5 92 + 54 C6 3D A3 6B E4 B4 3A 00 4A 80 B4 B6 1A 47 B7 + 1D D4 9C 82 1D 90 CC 95 EA 7B E9 B1 B0 3C DD E8 + 41 64 02 02 28 CA 05 E1 F9 68 C3 8E FE 0F 29 88 + E8 35 89 ED 20 D6 FF D1 B3 CF 2F 42 EC 95 02 D0 + 8D CB 28 D6 27 4A 1B 9A 50 CA D3 E4 95 D8 92 D3 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 9F E4 32 B2 05 B1 5F 6B 1A 1F D1 02 44 10 0D AF + 44 EA 90 36 E6 6E ED 58 33 A2 53 68 CA 34 DC 5D + C3 83 D9 05 AC FB 72 B3 D9 28 74 02 F9 41 FE 48 + A3 97 3A 07 30 01 3D D5 63 99 2A 6C F4 D3 1F D0 + C3 57 6B EC 65 0D 96 BE 2A A4 31 DB 3F 02 17 7A + D3 66 3C AB 6C 52 99 E1 7C 20 61 BF 9B 04 17 39 + 0C BB 1D 24 97 BB 33 84 42 3F C7 A6 C3 34 92 3E + 77 F5 1D 3D 3D CE 8B ED B1 8F 5C 9C 42 2D F8 53 +-------------------------------- + +:Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 22 E0 54 19 64 A9 D5 5C 90 60 62 0A 62 9A B9 24 + 38 92 95 DD +-------------------------------- + +:Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + DD 8D 2D 3A 9B E5 36 B6 77 FB 3B CA 04 9C 25 3D + 4B D5 C2 58 B1 84 24 AF 0B 73 47 1A +-------------------------------- + +:Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 1F E6 3D 22 D4 C2 FC 5F CD E7 12 56 67 93 FB 33 + DC D8 00 7E 56 70 55 58 0A 9D 9A 30 02 0F B4 2D +-------------------------------- + +:Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + D7 80 B3 95 33 E7 D2 93 6A B1 02 2A DF BD 3D 78 + 3E AD 03 47 60 93 FE E2 3E 7F 9C FB EA 78 8B 41 + D8 D1 9A 36 21 FE 1F B3 C8 14 D8 DD F3 3D 44 E1 +-------------------------------- + +:Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + E1 EE AE C3 8B 77 1D 8F 24 59 54 F8 A3 0A 7E 12 + B5 59 B3 23 13 D9 E7 BA 4C 9E 4C 5B 02 9D 3D 5D + 12 F8 D9 6A 6B C7 F7 56 B4 86 2F EB 64 C4 66 DD + BE 3D 5D B1 68 BD D0 3C 56 6C 70 BD 27 6F 94 54 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 6D 8F D0 3D AA 40 6B 2F E6 D3 6E CE F4 EE 1A FE + 37 D2 2D 7C 59 B7 67 CF 87 1A 75 20 15 09 58 E0 + 2D E7 CB 36 BF 4D 13 DC 44 D0 5F 32 DB C5 D2 A2 + B4 55 7D 77 46 83 9F 09 BC F6 96 81 3A A6 09 BE + 9F CF 83 9D 24 24 1A A6 4C 1C 1F B7 D9 C9 D8 4C + 85 ED A0 CA 19 C4 44 3E 19 4F 98 A2 22 AA 17 64 + 58 94 EE BD F6 A3 1B 6F 1D 13 C3 B6 0D CB BB 1D + BF 46 91 5D D4 EB AB 25 D8 1F 85 57 6B CB 0D 07 +-------------------------------- + +:Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + A0 1F 01 13 9D 9A C9 FD 59 E7 C3 5E FE F1 CA 4D + 92 C8 27 7C E6 95 83 74 15 DA B4 4A 8B 48 86 38 + 87 +-------------------------------- + +:Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 21 33 7D 65 8C 84 49 2E E6 13 0F E8 B2 3B A1 BB + F5 B9 D8 C0 A6 F4 9D DB 46 26 5A 36 8B B0 79 A2 + D7 6C 45 A2 DD 07 BD 92 B6 FA 6B D8 ED 7C ED 5F + F6 86 5A 40 DE FB FD 2D E7 EB FE D3 4F 40 00 43 + AE +-------------------------------- + +:Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + C8 3F FC B7 07 62 0D E8 51 3D B6 AE 5B FF BD 30 + 3A 27 5D 77 6D 5F EB F8 62 D1 59 1E F7 1F FC AA + 8C 8B C8 7D 89 CE A2 07 6A 40 95 F5 48 AB B6 D1 + 1D 66 31 02 4B 31 EF DB B1 D9 9A 75 39 33 7C 32 + CE 7E 57 6E D2 D3 2C 01 84 29 2A E2 B5 93 29 97 + 21 BA D1 5D 2D 54 D8 AF C7 96 74 89 30 93 A6 C6 + C1 86 A5 12 5D 7D EC FC 9C 61 C6 B8 DE B1 00 75 + BA D6 AC 72 37 E4 6B 86 AF 77 E0 D5 7F FD FF 50 + 0E +-------------------------------- + +:Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 +Result: + 9F 03 88 0F B1 4B 77 FB 32 39 46 A6 20 FA 39 D3 + 4F 21 22 1C F4 9A A2 FD CB 7E 93 DA F2 37 BA E0 + C6 59 A3 0C 9A 9A 4C AC CC E6 3B 88 5F C9 32 BB + C5 D3 0A AA 3B 2C 71 78 12 47 21 1A E9 B7 53 BE + 5E F5 BC F7 EA 7B 73 34 07 86 47 4B 99 E9 C1 D4 + 55 3D 36 89 4F AD B5 DF 4F 85 74 10 EB 4A 40 F3 + E8 62 65 C7 57 5B 4C D1 1A C7 B6 71 DA BC 6E 36 + C3 C4 56 94 88 49 2D 8F 99 ED 7E 21 00 44 43 6F + AB 6C CB 46 55 50 E2 2D A9 F4 B3 42 81 6B 7A 07 + A0 B0 DA A4 5B F0 48 AF E2 00 D5 AF 53 56 88 B0 + 9A 27 E8 AA 2D C7 CF 11 02 B8 A2 20 60 E0 B0 34 + B5 2B 8E 6E 72 91 A3 57 88 D2 B2 5E 77 93 51 50 + 78 7F 02 BD 2F 68 89 CF 6E 78 9E 5E CF 7D AB 43 + 35 30 B2 E8 4B 6F C0 9A 5B 04 FE 4A D6 CE F1 09 + 52 61 20 6A 2F 59 B4 0A 27 D3 A9 01 FE E1 61 01 + 3B CA C8 60 C1 9A 60 E3 73 C1 CB D8 01 F8 3A 22 + 76 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F +Result: + 40 1A 80 4E 0D 36 FC 5E 93 CC 91 9F 87 5C F9 08 + 4F 89 DF BB 91 EE C1 16 23 EE E1 2C AD DF 97 76 + 97 52 5C 2F AB 67 44 79 EB 30 77 F7 68 BF D6 07 + C8 BD BB A9 3E 76 98 0C 29 42 5F 99 46 84 DD 05 + A7 61 9B 6F FC 21 6D CC 47 76 18 94 C9 84 1F 0A + 91 BC B0 2C B5 87 9E C0 76 08 1F 1C ED 0A 28 7B + 5C A9 15 C7 E7 2C EB 13 A7 0F C0 05 F6 D2 7A D5 + 3B 02 21 60 11 DD CE 73 D3 B4 E6 8F 76 89 5A 6B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 6C 5E CE C8 D8 39 3C 5B 73 76 23 3C 0F 58 85 66 + CB 99 79 A6 DB 77 CF CC F5 71 05 7F B2 D7 06 EC + 1B C5 78 9B 7B 19 73 9B 3C 06 DA D0 6B F4 13 EE + 2A FC D7 49 CE 6F 94 EC D9 C7 0E B0 FF 17 01 59 + 03 36 37 43 FB 4A 04 49 DB ED 7F 7A 23 C9 A0 88 + EB 1A A3 EE 13 7F E6 C1 94 A3 92 A4 35 9C E2 16 + 7F 32 C9 72 DA D6 8D 79 6B DB CB 99 59 47 8B 28 + B9 DF BD E0 EB 48 FE B0 1B 64 4A 4C 1F B7 2D 6E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 +Result: + 36 1F 0F C0 76 52 BB C3 93 C7 C6 02 8E A3 52 35 + 63 90 10 B8 0B 25 6D 84 F6 66 2C 34 2A 65 FF A6 + 47 50 78 A1 98 A2 29 43 6F 27 0B 10 20 DE F5 E6 + 47 FE 9A 43 CC 7E C3 93 CD 47 AF 1A 01 F3 D7 B4 + 8A 45 52 06 92 95 92 92 00 32 50 FA AB 40 CB 81 + 59 9E 57 D8 3D 8F 73 76 00 A0 E7 BF 26 0D 83 00 + D9 F9 5D FC C8 28 5D 3C 16 32 7D 36 89 4D AD DF + 64 A6 C3 E1 FF 29 3E E3 A2 94 3E 48 6F 86 F8 3B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'incrementing' + +Message data: + FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 + EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 + DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 + CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 + BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 + AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 + 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 + 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 + 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 + 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 + 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 + 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 + 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 + 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 + 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 + 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 + FF +Result: + E3 0D F2 56 22 4B F8 94 84 3D 7B 40 64 AD 72 57 + 00 3B 3C 84 8F 8B 5D 81 9C 60 A7 F1 42 2F 1D F4 + E7 83 09 F3 CB 7D EC 50 4E A8 43 5F 0C 2A 7A 85 + BE 51 AF AC 83 40 27 75 87 9B 74 1B F0 84 FE 7A + CD 83 E8 D5 E3 07 9D A6 C8 FB 2B 55 A3 34 6E 10 + BB 56 94 4F D2 0B F0 5E 79 25 1D 39 69 5B 74 E9 + 83 09 6E A0 49 69 3C 29 56 53 75 D5 34 9D D4 B2 + 28 51 84 78 00 48 E5 E2 13 56 86 0E D7 46 41 A1 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 0 bits, data = 'random' + +Message data: + (none) +Result: + BC 27 63 F7 07 E2 62 B8 0E 03 13 79 15 43 A7 AB + 0A 4B 6C D0 83 27 0A FB 2F CE 42 72 E1 BB 0A A9 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1 bits, data = 'random' + +Message data: + FB +Result: + 95 D6 9B 85 23 E6 AB 6C 56 A1 E4 F5 93 A3 15 8F + 97 DD 61 42 49 A6 10 D3 13 0C 88 9E 3E EE FC 1C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2 bits, data = 'random' + +Message data: + FB +Result: + 0A B7 09 B6 40 36 4C 25 FE C8 86 53 03 77 BF 53 + 5A E4 EB 12 14 A3 C3 FC B5 B9 6D 6B 5D 09 E8 08 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 3 bits, data = 'random' + +Message data: + FB +Result: + DC 6E 6E AE 34 80 B8 F9 57 74 AD 1D D6 B8 B2 18 + 6F 4A F0 A9 96 D9 60 F8 8F 75 5D 7D 00 CF 05 E7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4 bits, data = 'random' + +Message data: + FB +Result: + 13 30 4D D8 50 68 E8 16 9F DD 88 42 84 AB F2 6A + 2F 4D EC 13 15 54 AA AA 7E 4E 64 F7 F7 74 14 1F +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 5 bits, data = 'random' + +Message data: + FB +Result: + 89 E9 7B 03 C6 97 46 AF A4 E7 8D B4 9E D6 77 C0 + CC F6 63 54 23 56 01 66 45 90 7D 61 40 AB BB EF +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 6 bits, data = 'random' + +Message data: + FB +Result: + 1E 6E 61 A6 00 07 BC F9 73 6C 9C 07 4A 78 7C C8 + DB 2F 76 02 06 32 E9 04 4D 08 21 39 C9 0F 81 D4 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 7 bits, data = 'random' + +Message data: + FB +Result: + 46 09 A9 F6 57 F1 B2 80 27 BC 5D 0A A1 FB F1 96 + E6 C2 86 08 5D 5C 0B E1 A7 38 E4 D4 0D 06 3E DB +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 8 bits, data = 'random' + +Message data: + FB +Result: + 5B E9 A2 10 AC 91 7F 49 A5 80 54 45 DD 97 BB 56 + F0 4F 36 63 99 CF 0A CD E4 22 FF 25 3A 3F 49 FB +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 9 bits, data = 'random' + +Message data: + FB D1 +Result: + 3A A6 98 C0 B6 A5 07 DE 05 87 75 D1 78 07 3B B0 + 41 7E 23 6B B3 A0 F3 B4 09 B8 75 6B B6 D2 13 14 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 10 bits, data = 'random' + +Message data: + FB D1 +Result: + CA C4 A6 3E 48 29 82 06 54 43 43 6C 79 33 92 BB + 1E F2 8F 63 2A DF 53 4E BB E3 5A 8B 1D A5 E7 E4 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 32 bits, data = 'random' + +Message data: + FB D1 7C 26 +Result: + BA 4D 44 62 35 18 D9 94 AD 01 9E BD B5 99 44 A9 + FB 46 17 D8 59 D9 2E 33 82 88 9D A4 4C B8 05 A2 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 64 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 +Result: + D5 86 2B B1 46 24 2F EB 69 DA 42 73 CF 20 34 EF + E2 2B DB 7B 61 2E 4D E7 2D 71 87 84 97 37 6B F9 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 128 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 +Result: + BB E5 C3 57 EC 9D 42 0E E6 23 76 E7 9D 3C D4 56 + 6B 7A 59 97 29 21 AF C5 B6 5A 99 8E 71 54 ED CD +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 192 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B +Result: + B4 AB EB 4C B4 8B DD 25 65 A6 5B 2E 61 14 BA ED + 24 CF 05 B8 24 2A B0 91 0E 1F FE 0B EC F0 3D C6 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 255 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + 3A 33 08 C1 6E EF 4E 24 E5 54 E7 60 62 B7 D4 D1 + E6 A1 3F 99 FA 51 35 7A 18 DF 9F 24 E7 58 B6 53 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 256 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + FC AE CD 67 37 C0 5C 29 06 9D 6F 69 98 63 97 C9 + 3D 0D 94 82 58 27 7C D0 47 24 27 2B 7C A9 71 34 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 257 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 +Result: + D4 81 8C 40 90 87 7E 0D 4F B0 2B 44 41 C3 15 F4 + E8 EF 30 8B 7D 57 14 3D 51 02 59 53 88 4E 58 28 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 384 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 +Result: + 88 33 39 A8 11 28 64 F6 8F 16 F7 35 64 52 0F 97 + DD BB 97 DB 56 8D 82 34 F3 BC 58 53 01 89 4D A5 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 511 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + 7F E5 A8 05 20 CD 44 3A 7D 3B 9D FF 35 32 94 99 + 68 97 BC 07 21 BB 51 1F 6E 29 F2 1F FF FB 62 44 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 512 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + B7 AC 80 EB B7 A3 67 17 C7 19 C2 A2 F3 08 C8 8A + 32 66 FC FB 88 93 C4 96 15 AC 98 BD D5 92 F0 EC +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 513 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 +Result: + 04 5A F5 21 3B AF C6 B5 4F 20 1F 4F CD 93 5F DD + FE 10 C9 EC D7 46 27 EB FF E3 B8 E7 47 29 C0 14 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 768 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A +Result: + A9 8C FE 1F C4 71 F0 E7 BA 28 08 46 67 38 DF 24 + 8C B1 9E 62 15 BF D3 06 50 FC 29 EF 40 FA 32 1D +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + EB BF 6A F6 A4 75 54 C7 3A 64 B3 09 DF 2F 8F 3E + 8E BF 34 A3 82 8E 1C 39 43 9A 5F 88 D3 FC C8 4D +-------------------------------- + +:Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + B0 FB E7 79 30 89 98 06 74 29 23 E2 F4 FE B1 A5 + A0 D2 D3 1A +-------------------------------- + +:Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 5C 58 31 88 EB 6B D2 D0 B9 C8 6C BB EF D3 70 5A + F8 80 36 DF E3 E7 2A 5A A7 E6 CF FE +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 23 EE 3D AA F7 6F 75 DA FD E5 EB 7C 80 1F 3F 77 + 23 27 29 0D BE 18 46 E9 78 AD AC 97 F5 FA 2B 6D +-------------------------------- + +:Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 6C E7 A8 67 97 68 28 E3 42 DD 95 43 C0 CC 7F 79 + D0 21 AD 3A C3 16 00 9C AC 42 D5 92 7E 96 58 25 + 7B 46 E2 14 08 83 7E 0C 12 08 24 81 80 09 41 F9 +-------------------------------- + +:Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 39 81 94 1E 3A 69 56 6B AF 29 54 5B EE 37 6B CA + 29 D4 AF C5 C7 2E 89 0C B2 BE DC 81 9F 38 74 32 + 35 9D C9 CD 8F E7 CB F4 0A 7B 29 51 8D 37 00 41 + 7A 39 12 D5 33 96 D3 C9 C1 6E AC 83 84 79 AD FA +-------------------------------- + +:Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 92 92 4B CE E9 95 61 1F D8 12 49 8C 02 5C CF 5A + 7E DE 08 C1 06 EC EF 8F 3D D8 56 38 CA BF 41 3C + AD 54 EF 7E 6D 6C 74 8F AF 9B EA 10 7B D0 43 32 + D5 06 52 95 B1 50 81 DA F3 A2 C3 CD EF 2A 61 72 + 79 1B A1 E0 93 CD 31 22 DC 59 66 35 3A 00 9B FA + 3A A3 8D B3 3C 8D 3A 09 9C 45 09 83 A1 95 77 A4 + 65 03 5F 98 EC B4 6E F6 09 49 98 55 E1 03 8F 1D + 99 4B 27 B2 19 02 27 54 CF B2 DF 1A 04 ED 15 CE +-------------------------------- + +:Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 0E 91 45 A2 AE 21 F8 1A 5A 09 A6 C4 F4 FF 35 F3 + 12 F4 37 E8 49 09 70 EC E2 22 DF 6E C1 B1 61 B0 + 60 +-------------------------------- + +:Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 68 21 D5 AF A0 3C DA 6F 40 04 36 49 2B 73 60 F3 + D5 A3 B6 44 2C 29 62 62 1A BF 11 16 22 45 74 D5 + B2 9C 35 F6 50 0A AF 3E E5 47 6C 13 93 DD 07 45 + F1 A8 11 DF 46 AA 49 7F F5 BB 48 2D C0 B5 75 E7 + 8E +-------------------------------- + +:Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + AB 38 D8 AB A8 AD C2 AA D7 04 A6 F6 A3 38 C7 24 + AF DB 26 0E 48 63 31 3D B7 0B B3 64 87 CA 98 8E + 5D 8C 25 CD 19 46 B5 80 ED 52 49 10 B6 74 ED B8 + A3 01 4F 25 6A 4C BC 5E 4F F4 AD 0F EB 16 7B C1 + 52 26 3D F2 6E EE 68 A2 39 34 22 20 E2 5C FF E1 + AE 14 87 45 D8 F0 31 D7 5C 34 2E 12 F3 24 A9 51 + EF 89 2C 05 1A 80 69 01 71 6C 86 1B 07 E8 59 2F + 35 B6 ED 60 28 FE 27 3B 47 1E 1B E6 F6 C7 9F 6E + 4E +-------------------------------- + +:Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + D8 5A 58 E8 0E AE 4C FA BF 12 F4 FC 48 44 12 8D + E7 40 14 6F AF CD FF 0B 23 10 17 22 73 91 4D 1B + 74 74 0D CE 8A 9E 0A 1C B4 0C 69 3A CE CB 11 C4 + 46 D8 DB 89 BC 11 B2 F5 A8 81 AA B7 EF 73 32 11 + F8 3D 2B FA 2A E0 59 D3 EC 22 75 49 EC 1C 5F 13 + D9 9F D6 C9 7B ED 61 5F 8F B4 12 6D F0 7A 0C F6 + 56 B1 2B D8 8B 67 77 24 15 83 20 DC DA A9 38 AC + CD 28 71 17 53 9C D4 14 74 BE F7 AA AC FC B1 2D + B4 16 98 4A E6 50 56 8F BC E4 C2 1A A1 9C FA EE + 6B 26 51 0E A8 D0 E3 A6 0F 71 FB 31 9A 66 2E EF + 00 AD ED 2B 83 8E AE D8 6C 92 A4 26 36 49 70 31 + EA 6A F6 5F 8D 9B 0F A8 E3 92 32 60 4F B7 0F 9E + 52 69 74 6C 58 B3 23 D8 A1 92 59 58 E0 F1 2B 32 + DE B8 53 BC 58 C2 D3 8D 9E CD F5 10 10 16 2E 85 + 80 58 E5 AE EF 39 A3 43 CB FA ED AC 2E 74 E6 54 + AF DE 55 CA 85 56 FB 31 73 95 4A 84 CE EE C0 C5 + 1A +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 +Result: + 79 D0 5E E1 48 E8 10 47 40 72 F2 8D 45 8E B9 8F + D2 71 7B 96 CF D5 8E 9C BF 8B 8A C0 30 86 FE 17 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + 4A 71 DF 26 01 79 A6 C2 E4 AC 9C 64 5B 77 8B F8 + A4 A3 95 54 A5 AD 24 6C 02 0E E9 49 4D EE 63 78 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + A8 5E E5 3D 6D 7B A5 2E 6E E8 42 24 93 13 7F F3 + E7 78 13 BF BF F1 FB A5 9D EC 42 50 42 7D 82 34 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E + 4E +Result: + 3B 0F 83 9F 19 FB 3E F5 DF F1 44 52 0C E2 B2 99 + 50 23 7B 69 10 FE 90 72 A1 95 10 9F 27 7F 15 77 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 0 bits, data = 'random' + +Message data: + (none) +Result: + D3 F7 26 3A 09 83 7F 4C E5 C8 EF 70 A5 DD FF AC + 7B 92 D6 C2 AC E5 A1 22 65 BD 5B 59 32 60 A3 FF + 20 D8 B4 B4 C5 49 4E 94 54 48 B3 7A BB 1F C5 26 + F6 B4 60 89 20 8F DE 93 8D 7F 23 72 4C 4B DF B7 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1 bits, data = 'random' + +Message data: + FB +Result: + 6E 69 B5 AC 4A 5F 56 87 18 D8 7A 9C EE E8 38 44 + 7E 3A 12 D9 C0 1B C9 6E 2E B6 11 3E F8 8D B1 DF + FD 95 53 E9 5D 75 5D 38 C3 BD 58 70 F8 45 A3 C2 + 42 7E 29 6C 95 13 B1 3B D6 3C 89 1E 64 33 4A 0D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2 bits, data = 'random' + +Message data: + FB +Result: + 9D AA 7F 12 99 73 C9 AB C8 AB A7 1E 4F C0 26 4F + 11 D0 74 C6 03 E9 11 16 90 ED 24 78 C9 8D 31 21 + 1C 71 5A D0 9B E3 85 8C 16 14 1E 50 C8 1C 31 70 + 4B C6 0D AA 0C 6F F6 95 01 FC 26 D7 0D D0 EC BB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 3 bits, data = 'random' + +Message data: + FB +Result: + 37 45 BD A3 9E FF F8 54 2E D1 D1 8E AB E8 EA D5 + E7 8A B0 12 E9 85 39 90 40 74 86 DA E0 07 D5 5A + 64 FB 9E A9 3F F2 EF 2D F5 A5 40 12 75 97 B6 D1 + F2 37 F1 29 42 59 01 A2 BA 06 21 83 CA 60 7D 49 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4 bits, data = 'random' + +Message data: + FB +Result: + 1B CB 78 F2 67 E7 8D AE 31 83 F1 AB 1C 06 DF 43 + F4 EC 54 01 0C 99 0F B0 3C EB 8E 16 CA 81 21 6F + 0A 80 1B ED 97 24 15 9B 82 4E 00 F7 3A 8F B1 A3 + 9E 79 F0 5F EA 17 EB 8E 4A 27 54 C1 1B 22 49 BC +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 5 bits, data = 'random' + +Message data: + FB +Result: + A2 13 59 7C AF 90 AD 52 14 A9 F5 4E 87 01 6F 42 + 08 57 DB AB D4 08 B5 F9 3E 72 A6 E1 44 2F 0C 70 + 96 44 9A A5 E2 18 6B BD ED 4C 74 10 C5 6D 1E E0 + 36 69 98 30 5F E0 20 1C 23 10 05 4E 14 C5 FD DD +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 6 bits, data = 'random' + +Message data: + FB +Result: + B0 2C 70 1A 97 2E 0C 7C F9 67 15 CE 2E 5E 90 F9 + 50 FD 14 A7 18 F7 A7 78 59 81 FE 53 42 4D 22 C6 + D6 C6 FC A3 F4 E2 A1 1D C8 50 4A 37 1A 0B 3D 55 + 18 92 5E A6 BD D8 93 0C 47 5A E8 B2 20 83 73 18 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 7 bits, data = 'random' + +Message data: + FB +Result: + B3 B3 E8 75 08 A9 18 B3 12 7F CE 9F 16 B9 6D 11 + 36 F4 D1 D1 4A AE 20 8D D6 B6 81 83 01 3A 88 56 + 68 B3 6B E6 1B 73 F1 F7 8F D7 2D E6 16 09 08 3D + D3 20 06 27 AC D4 A8 48 7A BD 22 49 3E E8 44 62 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8 bits, data = 'random' + +Message data: + FB +Result: + 2E 1E 7C 36 EA E8 94 1C 45 7A 1D 62 91 E4 C8 53 + FE 29 79 EA 4E 5A FC D3 B6 6C 87 4C 92 E2 63 D8 + CC A7 06 F0 97 DD 48 2D 13 62 C9 D3 D9 F5 E7 C2 + 8D 21 83 E5 9B 1A 11 92 C4 BF 39 E1 11 FB 83 6A +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 9 bits, data = 'random' + +Message data: + FB D1 +Result: + 4D DF 3A 04 02 7D 1A E5 9E 36 98 39 66 CC D0 AF + 6C AA A1 61 1B 71 F9 97 FE B3 F2 43 FE FC 61 97 + 7D 01 A4 B5 0F 6C 31 25 C4 81 E8 D9 E4 B0 C2 4A + 01 36 BE 3E 18 6C 44 54 4F 8B E6 ED 0C 24 3A 1C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 10 bits, data = 'random' + +Message data: + FB D1 +Result: + 0F 37 5F AB BC C9 0B 5F A7 7A A0 76 27 B4 96 C4 + EF 02 3D 73 F2 21 69 E4 87 F8 AD A3 CD 5E D3 6C + A3 59 52 0C 97 E2 04 D6 48 E0 C9 17 89 E9 91 8C + 02 59 C0 2E A9 FE 37 53 65 3C 42 C2 64 75 02 BB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 32 bits, data = 'random' + +Message data: + FB D1 7C 26 +Result: + B2 BF FF A7 E4 66 D9 18 66 ED 2E 1F 86 53 30 3E + 28 D7 1B 1C 15 52 D7 0E E6 05 D1 71 BB 8E BF AF + 27 ED 45 72 E3 64 99 25 E9 E6 BE 92 31 31 08 C4 + E1 8D 6E F1 91 D8 95 A3 C8 57 E1 0E 52 A2 A7 6A +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 64 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 +Result: + 57 E3 B0 A6 DC DB 9F 3E F4 22 BF 59 10 5E 6A 1C + 2E F3 50 09 8F BB ED C1 0B 8A 10 C3 8D 9F B4 05 + 72 AF 2D 7D FE 74 CD 47 4D 7B 4E 68 A8 FB A1 F4 + 16 F9 39 90 CB B5 C1 84 40 F7 05 5F 44 1C 42 A2 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 128 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 +Result: + AB D8 B3 D5 41 81 E4 4F B1 8E B1 E6 32 15 C6 96 + D7 3D 44 75 2D F3 01 E3 44 DF 60 DF 61 51 70 45 + 2E 7E 16 22 08 63 C3 DA AF CE 6D 7C C3 9F 6C 65 + 10 13 43 FF A2 E8 D7 14 B8 F5 EE B9 06 81 25 F4 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 192 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B +Result: + A2 6D 22 1C 96 C4 B7 80 5C 59 60 3F 86 53 80 62 + 49 E7 5F 9E 56 F7 E0 88 B5 91 CD 01 26 1B B4 76 + 99 97 3F 1D E4 CB 3E B2 3C 51 2C 9C 56 9C 8B 2B + 92 E1 B2 50 0B 48 B1 24 DE 12 F0 F5 B2 E7 0D 5E +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 255 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + 8D 44 26 CC F5 4C 3B C5 11 B8 60 5D B0 CB 2E 27 + 23 5A 8E B1 AA 0B D0 1B 46 2B DE 26 94 73 B1 E2 + 72 F9 F3 E2 64 3E B0 EF 1C CB F7 65 81 CE 1D 1B + E6 8A 6B 91 F0 17 4D BD BA 81 72 16 3A 5B 99 F2 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 256 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + B3 1B E6 E6 AC 8C 31 9A 63 24 07 F4 58 0A 32 FF + 6C A4 F7 15 C3 1B 73 87 00 90 A0 F2 04 BC FA 1E + 12 F9 4F 68 DD F6 51 83 C3 F0 79 EB 4B E4 00 23 + 1A C0 81 AB 88 3C B8 E6 FF 78 F3 FA 04 80 32 A7 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 257 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 +Result: + 3A B0 8C E0 6F 7B DF 13 B0 E4 41 13 1E AA 8E 49 + 34 F3 42 05 7C C0 4C 3A 67 B1 12 63 36 65 83 48 + 18 97 C9 06 01 85 D4 FA 6D 38 C0 7A A5 79 CA 93 + F1 5B C9 80 EC 3F 71 55 E1 97 10 11 06 78 E6 CB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 384 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 +Result: + 39 67 E5 75 AF E3 7B 8E 77 49 31 39 44 B7 6E 7F + E9 29 89 8C A1 D1 DE 2F 54 9C 06 AC 71 CF A8 C5 + CE A3 8B F8 88 AA D9 A6 C6 06 F5 98 B6 E6 01 78 + 77 BA DE E9 3C B1 10 37 07 57 D0 52 82 BF 83 1A +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 511 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + D2 62 E4 73 9F 87 58 81 53 45 B0 FD F1 EF D9 43 + EC A3 49 BF C6 D0 69 9E D8 F1 29 59 31 E1 57 F3 + AD 00 79 90 65 71 2C 2E 1C 20 02 79 82 DD D2 B8 + 6C F5 F1 02 94 08 8C 33 59 C5 C3 D6 FA 3C 21 EB +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 512 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + 00 26 F6 09 CE 2F 4F C1 89 2E 2A A5 DD C6 1A 0C + D8 D3 80 8B 09 D4 BF A6 44 8E 68 D6 4A 5A 4E D8 + 85 7A 2B 1E 8F 89 FD AE 56 4A 2C 37 17 8C 68 51 + A5 F7 62 5A B3 A9 A0 7B 08 3B FC 4F 86 0F F8 95 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 513 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 +Result: + A0 3C B0 3F 44 B5 04 B3 E6 AF AD D2 4C A7 EF 5A + 3E 16 71 85 A2 17 E1 BF 92 25 28 43 4D 20 64 DC + 99 A6 29 0D 74 93 4C DD F5 F9 46 42 30 36 69 B8 + 89 35 86 1E BC 7C A5 88 B6 AF DC FD D9 C6 6F 62 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 768 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A +Result: + 59 CB 6E F9 FB B2 7D 1C 2E 42 24 77 4D 41 14 F9 + 40 54 57 E6 D1 9E 30 48 DA A8 EA 5F 60 6F EB 65 + 43 C9 07 F7 33 58 CE 05 BA 64 A2 04 83 C0 85 EC + A1 E6 E4 8D E9 7B 53 D0 D1 31 2F A7 86 37 E4 83 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 5A F8 56 54 50 90 2F E9 53 C0 94 D2 76 7E 1C AD + 36 EC A3 B1 97 BC E2 5F 53 10 BC DA DC EB C5 07 + 92 BF 81 B9 6E C8 34 3A 88 A2 42 92 8C 8F B5 80 + EF 53 42 0D 1E 23 04 BC 15 23 C6 26 39 E1 19 01 +-------------------------------- + +:Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + DF 26 24 4A 4A D2 C2 74 6E 81 2C 83 26 E0 B1 24 + A8 97 5E 04 +-------------------------------- + +:Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + B3 FA 10 00 A5 C7 65 A6 74 70 D4 9E D9 04 E9 4A + B9 0C F1 D5 29 17 FE 72 A0 53 51 FA +-------------------------------- + +:Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 4A 49 A1 44 20 D2 61 DF DE ED 02 FC F8 FA FD B2 + AD 7A 99 34 6E 34 CB 89 E7 EC 04 F9 79 ED 05 94 +-------------------------------- + +:Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 74 86 7C 76 DC 35 D5 04 AF D9 21 F4 2B 0F A5 41 + 05 1D 80 9E 7D E6 96 A1 EB 38 92 52 28 AF F5 90 + 7D 7D C1 AF 2E EC F7 47 CB BD 2B FD 65 25 29 2C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + E5 C0 4C FD 7D 04 51 05 CC E5 73 54 79 7E 70 47 + ED 22 67 32 FB FD 83 4A CE F0 F1 DE 34 39 06 4C + 3D CB B0 C8 D0 19 78 2E 21 91 35 A2 9D 97 4A 87 + 38 45 63 09 60 E6 F2 8F AD 87 35 43 1E DE AA 79 +-------------------------------- + +:Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + F2 B3 19 C8 C8 64 FB C5 C4 0B 79 A9 3E 73 2A 61 + 5A CF 85 09 55 18 CC 01 AD D2 AD 99 5A 00 B6 6E + 2F 18 20 AA 2A 4D 85 2F FC 9D A1 54 5F 85 EE D2 + 9C 4E 96 C8 0C C6 ED EC 91 DC 85 70 A5 51 C2 43 + 5A 52 83 25 E7 23 E2 BE 0E C1 E3 FF 10 BE 3D 7F + 96 B1 93 7D 48 65 D1 0F 75 4C FD 43 64 86 9F D6 + 6F 2F 93 F4 3C 8E E2 E2 19 74 23 CB 5D 7A D8 83 + 5D 30 35 00 ED 1E 41 6F A9 F5 98 D5 CE 1F F3 A6 +-------------------------------- + +:Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 4C 6B CF AE 17 70 31 A7 8A B6 95 71 D3 5E A4 E8 + 4F 78 8C 90 14 7A 23 1F 45 10 82 DC 65 A1 A6 21 + 56 +-------------------------------- + +:Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + BE 78 15 21 50 C2 50 9D 95 71 6A FB F8 B0 75 A2 + 58 59 FE 0E 07 26 54 C8 29 0A 30 79 4F E8 A8 00 + DD 4E 68 13 6C A6 E7 FD A7 A5 2B D2 A5 E4 65 27 + D4 54 2A EE 05 05 70 CF 61 6D C0 03 D5 2B 86 EB + 0E +-------------------------------- + +:Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 16 E8 6B B5 B5 0B 4E 4E 3C 74 F5 29 4E F0 F7 09 + 0F BC 45 75 16 56 5F DE CE 38 EE AE BD 5A AE 7B + 1A 75 0E 01 04 6E 64 54 3E 91 09 D3 74 2E 6E CE + 86 3F 08 26 8B 7D FA F7 DE F6 D6 46 FD 04 35 77 + D0 05 50 36 34 1B 17 FD 30 D8 D6 4C D8 7B 87 89 + 25 00 42 A8 FE 58 40 FA 55 CB 0E B5 A2 A0 25 4E + BC CA B2 BA 1B CB C7 89 00 AA 0E BE AB D0 97 53 + 77 DF B2 14 22 93 97 9A CB C4 E5 F9 23 15 88 2B + 50 +-------------------------------- + +:Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 80 1E D6 E9 C8 B2 B9 28 DA 80 27 FC 72 06 FF 6C + C1 60 EF ED 65 8B 9B 1E 69 30 7E 95 17 52 5C AD + 0B 1C FB 0E D4 68 06 48 6C 81 E8 38 60 17 8F 62 + 10 28 B8 29 62 24 E5 D5 60 19 7B 47 DE DF C5 0C + 61 A9 74 64 03 47 15 0E EF 24 88 6E 01 E6 7E A8 + 7E CD 21 BF 05 11 B7 E1 85 DB E9 BB F4 46 E3 24 + 3D CB 24 8D 86 20 CA 05 22 5F 4C 82 D3 61 F2 95 + 8B B2 6B CB B0 74 8B 09 42 EF 8B 89 5D 63 38 BD + B8 47 56 F7 38 EA 9C F4 F3 FB C6 D7 F3 8D FC 20 + B5 20 97 E5 B1 4F 02 81 71 CE 5E 05 AB 39 77 41 + 91 34 5A 6D 60 A0 A8 DE 77 DB 4F D5 58 7A 9F 9D + 72 AB 76 27 19 D7 A7 9F 5B 75 D5 72 AB DD B8 38 + 0C AC D1 F4 7E 0F F4 FB 05 CB 70 AB 4E 31 54 4D + C8 09 6E 3D AF CD 32 A1 97 C5 56 D5 AD C7 89 DF + FE 0C D3 7D F2 F7 79 7A 90 D4 ED 76 C8 11 C8 02 + 81 7B 19 7A E7 0F 24 94 E9 DD B3 C3 2F 49 47 AD + D0 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 +Result: + 8E 83 4B 50 52 A4 45 1B D6 35 BB 42 94 3C 6C A0 + E9 4B 51 68 DD A2 8E C5 8E 3B AA 77 30 E8 6B DC + 31 E0 EA 2C 2B 71 40 E0 BE 39 D3 29 29 8D F6 44 + 9F FB 1C 01 56 4E 0D E9 6D 19 C7 B1 E8 B5 5C C3 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + 18 E8 03 96 9A B2 A1 C0 2B A0 80 9D 4A E3 4C 7D + D9 1F 73 C7 AB 8B 5F E3 02 A9 C8 E8 98 0F 07 96 + B0 7C DE 33 76 58 F8 08 DD F0 96 16 88 3D E8 87 + 14 45 65 F1 29 2A EA C6 0A 18 2E A4 52 A9 29 7B +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + D4 AE 6E F0 FF 7E 8D C5 AB 02 1F 9D 6D 9D C7 69 + 25 FC 2D 5F 9E 09 2A 63 86 70 45 CE E3 F3 5C FA + 8F 63 A6 C0 2B DE 67 DA 2C 6F 7D 82 27 B9 77 42 + 74 A5 0A 49 D3 8D 62 F7 0A B8 92 0A 44 00 AC 20 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E + 4E +Result: + E5 86 81 CC 28 44 F0 53 7E CB CC 7A 37 53 CA 71 + F6 EA 74 E3 07 8D 4E 07 FA AF 12 2B 83 6A A9 26 + 8C 6F 4F 8D DF 8E 70 D3 BD 72 47 CD B9 06 66 E5 + E8 7F 8D BB 0B C0 99 1F 58 73 AB FB CE BC 72 E2 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'random' + +Message data: + (none) +Result: + 7B C3 CE 31 C0 35 DF 3C 7A 7D 55 9B C9 D9 45 4F + 87 9F 48 49 7C C3 9E 6D 14 E8 19 04 98 45 5F 39 + 6F 45 59 04 05 C4 A1 5B D0 AB 29 F5 46 7D 91 32 + 80 2F 43 54 37 6E E8 64 AD 9F 20 0E 39 A3 D0 9B + 9A D0 6E 9D 0F 65 6C F9 1E D9 DE AC 13 A7 A6 7A + 82 AB 98 3F 52 13 31 29 CA C2 A4 DC 13 FD 29 C3 + 6C A6 C7 2D 6D CC 6C 82 C6 67 97 F6 B7 60 7C B0 + E0 F9 00 6A 27 B8 3B 60 C5 9E 4B A1 8D E2 33 E0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'random' + +Message data: + FB +Result: + 7A 02 04 48 B7 6D 52 9C 8E 65 D8 F9 E8 07 DB EA + 56 44 47 35 9E 18 C8 F8 2E 46 F6 66 DB 69 88 0C + EB D7 AA 3E 85 03 1B D8 65 4E 43 B9 F1 9A 39 A7 + 58 C1 CD 14 F2 1A 0A BB 71 10 B5 56 C3 94 4B 51 + 6E 71 EC 1A 4F F9 72 69 56 5B F4 40 34 83 96 58 + D6 AD 2A 97 44 24 2C 19 E5 13 A6 B3 62 70 00 46 + B8 70 A3 25 E3 BB EE C3 DE FD 85 FF 06 CE 73 A6 + 9E 0B 68 90 2D 67 54 C6 24 03 47 DA 92 F4 29 1E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'random' + +Message data: + FB +Result: + 8B EB F3 30 C1 36 16 8F 4A 16 46 36 32 30 1E BE + 45 DF B2 79 78 6F 82 B9 DE 31 1B 69 03 45 F9 01 + B1 52 8F 8C 8A F2 22 1E F3 30 51 14 D9 F6 8C CD + A4 B8 42 AF 8B E9 B6 5C A8 23 B4 92 31 B8 EC A0 + 46 98 4B BF 82 64 A6 C8 19 87 89 6B 04 D0 D8 92 + E6 DF BB 08 19 DB 71 BC 00 6B 5C 74 DB 5C 53 29 + 54 F0 DE 22 88 26 5B C9 BA 66 44 16 54 FB 29 8D + C6 46 AD 0D 03 80 26 E8 9B DD 91 F7 C7 5E 69 BA +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'random' + +Message data: + FB +Result: + F2 89 AA 9B 6F 60 4B DD 66 B7 81 BA 80 28 CE 27 + F5 00 04 D7 0B 48 F9 3A 09 B8 52 D5 15 7C 9C 41 + F6 86 9F FE 6D FA 8E 9D 91 51 5E 22 30 19 18 87 + DD 0B 91 12 00 09 E1 A8 61 00 46 E4 74 34 8A 1F + 1D 7B 44 36 28 3F 55 32 10 D1 F6 CA AB 13 99 FC + 81 AC 8C FA F8 5F FD B8 35 2A 1C 78 76 03 FD 07 + 88 58 2A 2C 8A 31 64 A2 DF 61 87 C4 13 AE 76 83 + B0 54 62 5C CE E0 EC 6B 9A 9F 79 A3 8B 4C EE BE +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'random' + +Message data: + FB +Result: + 41 3F AC 75 E4 C2 C7 7F 4C B1 DC 48 EC CC CC 07 + 2E 36 73 8B BA 67 9D 5B 81 BC 11 19 88 15 05 18 + A5 DA 6B 17 0F 8F FA 45 50 EE 8D 7A 18 5F 4D 33 + C5 15 20 66 90 7D 31 8A E5 A1 8B 42 90 94 92 20 + 3E 1A 63 EA 86 7C ED B9 97 F2 A6 AD DA 27 C5 5B + 37 E1 23 98 78 6C 74 4D 54 BA 65 A0 8D 1B 5B 6C + 9C 00 34 20 25 B3 EC 83 F2 B3 F7 51 31 83 9C 73 + 63 A9 0D 8C 1B F2 35 02 7B 50 4E 03 77 64 D3 AF +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'random' + +Message data: + FB +Result: + 2D C5 A7 16 D3 2C 6A E0 6F D8 46 99 9D D4 50 E2 + FE 5E 6D E9 62 A6 C8 4B 22 57 D7 60 E9 88 C3 5B + AF C4 9B 3E 71 14 A3 51 6F E6 28 78 65 3B 63 7E + 4B 0E 8D 95 62 52 C4 21 E8 11 33 5C 76 84 24 B4 + 79 30 5A FD 78 3E 47 DE 15 8D 60 9B DA 26 66 DE + 80 5E 2B 21 24 A2 21 95 EB 4D AB B4 63 7B 4B 17 + 27 97 00 FF 16 07 E8 FD 32 FE D0 BE 5A C7 28 C5 + DF CC 63 A4 90 99 64 1B 58 2A D7 54 54 A6 8B C0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'random' + +Message data: + FB +Result: + A6 0D 91 35 65 B4 16 F6 B0 2B 22 1D B6 0A 1B 4D + CC 0B 61 81 CF 52 4B DC 7A F6 01 79 7E 60 62 21 + C0 B7 83 9F F7 DA 15 C5 DD 30 D9 A7 04 B4 C3 DD + F8 D6 7A D3 CF 7C AE 79 13 2E 23 0D 0D 7B 3A C5 + 01 A3 08 E2 19 C8 2E 9C A0 35 1A 7C BB BD D1 27 + 15 51 95 90 EB 71 6F CA C0 3E D0 D1 BA 71 18 7D + CF 6F A6 AF 3B 7D 3B 68 2B FB 8B A9 2C 8F 73 38 + 6F 8A C4 A4 50 3D FC 0D 34 7D 85 A9 7B CF 37 5D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'random' + +Message data: + FB +Result: + D0 EB DD 70 70 E3 5C C6 25 F8 F4 74 20 18 10 89 + B3 C0 BB 11 7F F8 DC 05 8C F9 69 DA C9 F0 F3 B5 + FB 48 DC 24 84 43 AC 54 7F 46 FE 93 E8 3D A9 7F + 2B 92 D5 57 CB 3A 75 02 53 CE 16 78 8F A5 8A 84 + A9 6F B4 A8 10 0C 55 B6 F3 D8 ED 0E 74 FD D2 D6 + AD 2F 68 29 11 B5 EC 32 AA 07 5E A3 A9 8B A8 38 + 15 4E B0 A7 F9 E5 A9 4A 51 B7 1B E4 EF B6 D5 10 + E9 D1 B5 14 7F 15 0D A9 9C 8A E2 CB 47 0B A1 1A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'random' + +Message data: + FB +Result: + 02 27 1F 64 1A 7B 99 55 E9 B0 79 9A AA 67 87 38 + 9A 9B C9 9F 4D F7 62 25 C0 75 7C C7 70 B5 09 B4 + 59 5B 9C 2C 9D E3 2B 7F 97 D5 BE 82 9B 26 A9 39 + 73 60 A4 6E E9 7A 42 80 93 EE 4F 2C 53 90 42 93 + C4 4E BE 13 42 3B 06 32 0D D4 36 02 E9 C4 D8 B8 + 05 2F AE 2B E7 5F 10 9F DC 79 CC 64 96 54 C6 37 + 04 EA D1 F8 92 EA 18 A1 79 9E DF 6B AB 70 D4 BB + D8 25 13 17 41 CE 9E C4 3D 7A 0C AE 67 4B EF 3F +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'random' + +Message data: + FB D1 +Result: + E7 4E 0B 05 68 C9 C8 4A 99 16 7D 5C 23 25 69 CF + F6 C2 73 D4 A4 CB 36 3C FF 55 A9 EE 38 D5 76 3B + C1 9D 8B AA CB A2 E1 33 33 A0 51 74 46 41 5C B9 + CB E1 74 BD 0D E8 2B 36 CD 37 E5 30 C1 B5 7E F2 + 29 E3 BC CD FC 50 7E FA 2E 82 80 21 8F 65 9A 81 + 37 1B BD CF A7 10 AA 8B B0 87 43 F6 8F D7 10 4C + 67 28 AB 43 A0 13 7A 78 52 C4 D9 66 6C 2B 2F 48 + C3 25 F2 B1 77 D7 68 DB D9 EA 92 E5 44 6E 25 CD +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'random' + +Message data: + FB D1 +Result: + EE EA 24 F5 9A CA 2F 85 02 04 F7 3E 4F B5 03 C2 + 22 9B AC A8 30 56 37 70 74 A4 67 CF EF C8 2E 11 + 83 3F 57 13 46 C2 4F 7D 1F 60 FB EA 10 4A C8 37 + B5 57 B6 BE B2 6D 6D 4D 4A 92 73 2C 25 D3 03 F9 + AB 58 73 5B 43 47 DB C5 E1 82 B0 A2 05 C9 68 6A + 68 62 15 CB 7C D9 98 13 D1 4A 14 49 59 6C B2 E3 + 24 B6 41 CA 14 89 3F 18 43 77 2D 74 94 04 33 48 + FF 04 65 27 5F CC 92 E2 68 7C F4 1D C4 1A 51 87 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'random' + +Message data: + FB D1 7C 26 +Result: + E9 D7 9A F5 A6 6F A3 C3 D3 CD B4 44 0B C9 9A 61 + 5F E8 93 DF 8F DF A6 04 F4 49 ED BD 60 FC 84 B1 + 68 9A 87 09 53 C2 C7 AB 17 FB CE B9 76 C5 BB 61 + 83 BF B8 12 AF 4F 7D B7 7F 62 3C 03 0B 9D 65 DB + D5 DE 1F B5 E0 43 83 52 16 3A 34 DC 63 E4 25 13 + F1 AB E7 61 48 3F 95 D8 42 17 32 82 76 D7 05 74 + 14 4E 6F 39 FC 81 89 A9 F3 62 10 5A FC 63 EE 82 + 04 DA 0B 17 42 23 DA 65 8D 72 26 4F C2 C6 BD 04 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 +Result: + AF 62 D5 13 4B 7A 30 23 F7 CD BC E6 05 5B 65 DE + 2C 32 21 44 D4 99 5D B4 C5 20 2D C4 AD 6E 1C A4 + 0F A8 4E 08 A5 5A C1 0C 58 EF 89 04 28 B8 86 D7 + D3 BA 37 7A 86 86 45 A0 03 F4 04 64 5D 7C EF 6A + B2 0A 57 68 CA 58 6B E3 8C 0E 3B 2C 83 E4 A9 7D + 80 94 5F 71 B1 67 8D 69 0D 09 88 A8 C5 B8 B0 BF + 93 66 71 FE AE 6C 92 32 9B 8F 62 DB A4 A2 DC B6 + 51 3D 0B 4D AF DD EF 2E 96 71 57 E7 AE 5E 61 DE +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 +Result: + 4F E4 93 30 D8 D1 8F F0 CE 12 B0 B4 6E 87 61 1E + C3 6E BA 24 C4 85 9D 7B 3E 25 A9 F6 52 9B 7F A5 + 89 92 77 83 54 48 12 75 5E A3 6B F8 BF D3 4C 95 + 22 41 C3 60 37 C0 33 5F 1B 4C 1F D9 10 44 84 23 + DF BC D0 73 D2 4F 56 60 17 07 02 2B B7 79 41 73 + 09 93 D8 F3 6D 6F CC 08 12 C2 17 60 38 FF 15 DC + 67 A1 E0 54 EF 82 99 D3 90 A0 34 60 03 10 BD A4 + 01 9C 7D 75 71 0B EC 28 70 0B D4 6A DB C0 D2 A9 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B +Result: + 03 F0 E0 C1 E4 EB 06 99 C7 A9 12 79 5D 4F 59 30 + 66 E2 D5 F7 3A 57 AE 4C DB 36 72 9E 47 30 79 7A + F2 67 07 03 C2 C6 7C EB B8 CB 70 57 AF 26 E9 3A + CF 7A 71 85 8B 5B DB 72 50 76 03 50 8E 01 B6 20 + 6C CA 4D BF 13 06 4C 86 ED 44 BA 06 C1 5C 85 BC + 42 74 F3 70 A1 77 5C D4 FB 25 87 AF A2 93 3C 38 + A9 F2 07 A6 B1 33 0E 7F CA 0D C1 0C 1C 81 33 A2 + FE DA CF F4 0A AC 53 8A 86 62 43 85 01 51 F3 FC +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + 9A EE C3 F0 3B 7A 59 8C CB 60 F8 91 EF B9 37 03 + 45 12 F5 B8 51 76 B4 AF 00 B5 61 E8 CE 09 82 E8 + F8 64 3F 0F DA FD 6A 9B B1 0B F7 5F A8 A7 4D C0 + 4A AB 5E A3 C8 13 B3 CE C9 68 BE 29 C3 B4 F6 2B + DE 99 18 76 2C A0 7E 1E E0 46 C8 AC 24 77 94 EE + 6E 83 A3 CF 5B 79 BD C4 F4 01 4E CD 27 CA A3 64 + 7A 04 2E F5 4B 4D 35 25 1F 11 85 61 CF 59 5B 7D + 69 A6 02 40 D0 6D F0 E1 E1 C7 9A 81 7B 14 16 63 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 +Result: + 3B 9D 83 F0 B2 20 23 20 19 C7 7D 3F 7A 44 36 4E + E0 C3 1A 07 81 EA 8E 12 EA 6D 3C CB 99 6B 8C 9D + E0 42 44 04 7A 43 C6 7F 9A 22 58 F9 CB E1 51 A8 + 3F D8 5A 41 8B CA FC 30 16 9D 7B 4F B5 01 F4 19 + 4A C7 47 5E 4D F3 B1 72 CB B8 2D 9C 2C 0F 8C 7B + 1A 2F 18 61 8A AB 87 4F 4F C0 C9 0F 9F 3B DD 8C + D2 80 D9 25 29 58 EA 3C 72 80 2F 7C BC E9 B6 65 + EC 38 DF 6C D6 56 6F EC 44 57 ED 7C A6 F5 2F 91 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 +Result: + 34 33 EE 71 AF 36 C7 39 B3 4F E0 FC 10 0F 1E 51 + 77 BF 01 C7 55 B9 42 67 CE 13 26 69 0F 94 42 A5 + 3E 65 72 10 B0 1D 60 7C 4D 63 AA 7B F1 A6 47 C6 + 5E B6 92 FD 37 F4 DA 00 21 F6 D7 52 80 59 38 49 + 83 38 4D AA F2 DD A5 96 D5 62 EB E8 08 DA B7 D2 + 70 08 79 54 AA 92 96 BF E2 56 22 CE 0F 74 49 12 + 38 B9 87 FD 05 3A 4D A7 D6 A9 CB 52 44 64 FF 38 + 0B 9E D1 47 24 FB EB 33 E0 BD 5B CF C1 2E 9C 3D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 +Result: + 59 BB A2 A3 E0 24 FB 3D 96 32 2D 41 08 57 83 04 + 96 40 1C 21 C9 A0 97 0E 0F 89 D5 57 03 7B 93 51 + 38 EE 53 7E B8 1B 20 1E 53 89 B4 45 3B 7A BC 0A + E3 23 7D C7 3E 0E 74 99 E8 E0 03 5A F4 4A 4B FD + 4C 69 C6 D9 75 36 21 09 6B DD 40 08 AB E8 12 FD + 56 38 5D CB D9 A6 FE 89 D2 CB 96 C0 D9 90 1C A0 + 76 FF D2 E1 CB D5 C3 90 AA 9B 17 6D B2 8C A5 C9 + F7 BC 4C 33 09 23 26 E5 F4 96 FF 21 B4 3A 75 0D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + 28 7E 32 41 85 B5 8E A6 1D 08 99 BE E3 9E 3A 0C + 0A 7B C6 2C A2 F4 3C BE 21 D3 79 7B 87 CB EC D4 + 2C 9B 21 3D 9A 4F 9D 82 55 A7 7B F6 6B EE 00 F3 + 8D 8B 67 AE 89 1B 10 2D B4 48 4A E5 D9 4A 4E B6 + B2 E5 DE 7A 24 73 8C 2A 9C AE FC 66 21 73 90 11 + 2A 6A 85 1A 35 48 91 CE 50 FF D0 2E D9 2F A1 E6 + 60 13 7D 75 EC 62 63 BB E1 45 5A 81 D8 FE E3 4E + 18 9A 16 A4 B1 E4 74 29 4D A0 BA 20 21 6C 9C 9D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB +Result: + 8F 3E 56 5F FA 8A CC 8E AD 41 4C EB B9 0C C1 37 + 16 94 7E 81 8D 0C 5C FB 0E 0A 40 1A F5 EB ED DA + F1 6A A9 C3 DC AE 07 BF 19 30 10 74 43 62 D3 F5 + 74 6D 98 E7 D1 1B 81 9A E9 EA F3 FC 63 5A 68 B7 + F5 CB D3 81 15 48 FD E6 E5 C6 0F 94 65 0A 67 55 + 35 E3 5E 1D 13 2D 76 34 D9 EC B2 51 98 3F E0 90 + 92 0A 70 5F DC 58 3E C3 18 33 16 FB 44 07 6D 27 + FC 6B E4 CC 0C 25 D3 28 F5 8A 01 59 DB F9 2D 6C +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 +Result: + 7F 01 F9 18 29 21 B5 08 A1 FA 87 7F 63 6A 96 52 + C6 AC 25 BD 58 79 18 64 EA 41 9A 89 10 78 BC B0 + AE 95 0B 33 43 50 39 72 3F A2 9F F1 AB 42 65 F8 + B2 96 28 C1 FC 8D 0B 62 94 F3 61 69 EF B5 CF A5 + D1 57 93 AC 0D F7 18 E6 E1 2B 15 0E 84 90 F6 14 + 00 FC 5D 35 2D 03 A9 0E EA 73 1D 5A EC 21 AA 15 + EC E7 CF EE 93 CE 5A 8D 82 26 8D 55 67 F6 46 46 + 57 B7 2E C9 12 94 AE BF 85 1F D4 FF B0 43 C3 DC +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A +Result: + 63 91 BF 88 62 9A D6 E5 61 99 3E BC 2D 95 63 CE + 2D DA F4 BD 7F 68 85 DD 39 E9 CA 0D 49 18 54 EE + F8 52 9B A7 04 F3 B5 1F 2D D5 73 D9 FB 40 9D 11 + 83 F7 3D 57 91 2C 4B B7 FB 8F D8 CB 60 64 CF 76 + 40 E2 48 E7 F5 C2 79 C0 9C 06 B2 17 8C 66 15 34 + 2C 86 5B 43 F4 EB F9 CC 11 51 0B 5A 8B 78 7E 38 + 4B F7 20 3E 5B 1C 4E ED 3D E1 7D 70 F9 ED 50 6E + 89 E7 92 03 60 F0 E2 12 EE 2B A4 0F 64 35 BC E1 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + F9 07 24 CE A7 3E E1 70 E2 C4 5E 3A 63 76 77 04 + EA 91 AA E1 20 15 29 B1 EB 2F 20 2C DC 65 1B 82 + 96 A7 52 7C B1 35 C5 99 3A 53 EA 6E D3 33 83 78 + E3 1A 17 3E E8 E0 85 C3 96 60 16 74 65 09 4C F0 + 92 D0 25 C2 A8 56 65 CC FE 7E D7 A7 70 8C 55 03 + 02 5B E3 D4 15 8E B0 DE 5B E3 49 4D 6F 3A 09 CE + D4 9E 97 BF 96 40 D5 BC 11 2D 3F 7B CF 5A 01 3D + AC 22 A5 16 7C DD 70 B3 3E 67 27 D1 42 0A 69 8C +-------------------------------- + +:Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + EE D2 F8 2B FF 82 2A E5 EB 46 93 E9 A4 AC 4B A4 + 0B 7D A0 1F +-------------------------------- + +:Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + FF 31 9C F5 23 9D 3C E5 82 5D 9A 73 7F 21 E5 6F + 2C FB B2 91 60 DC 30 CC BF 50 9B DC +-------------------------------- + +:Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 43 72 B2 9F FC 5C D2 FA D9 9C 3A 71 12 2C 05 07 + 15 B6 41 17 F7 05 8D 5C C9 D5 6B C9 61 B2 31 C6 +-------------------------------- + +:Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + D7 F9 21 6E 16 2B AA 4D DD 74 8A 7B D5 76 1E 93 + 17 DD C6 25 99 0A DD 7F 56 58 2F EE 49 A3 54 1F + 6C 6F 0C 15 F9 8B 1F 2E B1 74 03 C7 E8 9B 16 01 +-------------------------------- + +:Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 48 C7 A8 05 4A C5 B2 C4 8F 14 DE 3D FC 55 F6 49 + 71 39 59 5F 88 4C 5C 50 F3 B1 DF 51 E3 14 72 0E + EB 95 9E 1D F6 4D 2B C3 E2 81 18 EA 6E B4 A0 1E + F1 9F CA 1B 7A 01 34 B4 C9 E9 CE AD 59 8A B8 8A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 82 79 3B E3 E0 4E 86 9B BD CF 88 AB 75 34 20 E3 + A9 84 6C CA 07 42 48 63 85 04 C0 63 3B 1D F2 15 + FA E5 34 8F FA 8F 05 C0 E0 AE B7 51 BE 3D 32 CA + 35 C7 8D 61 83 82 B3 41 0C DD D9 D0 02 B9 5F 5D + BF 5F 90 C5 41 26 1D 56 87 72 CA 71 FD 54 33 F6 + 52 FE 31 A9 4F 7B 47 C1 44 F3 99 D4 E0 8C B5 93 + B0 ED 54 70 89 4B 36 D1 6F 56 16 0F 4F A9 0F 0A + 55 EE 97 0A 67 2E DF 64 38 AC C2 F9 7A 53 C9 F4 +-------------------------------- + +:Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + FD A2 51 3A 3D AB D3 A5 6D 24 E1 6A 43 66 FE 43 + AD F6 CF 42 0F E6 02 85 EE 3B 67 0F 1D 30 B5 6E + BA +-------------------------------- + +:Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 4E B0 32 13 0E 15 6E 9E A4 85 72 26 93 41 F2 67 + E1 BC BA BF D9 27 4D 34 34 8C 4B 4D 11 36 A6 8B + 95 44 53 03 0A C3 34 64 72 02 F1 7D 3A 39 2B E6 + 7C BF 60 1A DA 90 23 47 4E A6 6F FD C9 7D E2 B1 + 74 +-------------------------------- + +:Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + BF 80 DD D8 B8 95 35 EA B5 0E 7B BD 26 8B 49 99 + F6 FA 63 51 BD F9 4E B6 DC 08 D6 70 F4 AC A3 AF + 25 FC 31 A4 12 49 89 30 92 0E 5A 87 96 98 AA F8 + 10 23 D5 FE B9 2C 0C E0 FC 81 AE 7D C5 91 3F 80 + F3 30 91 96 F6 36 3F E4 EB 1E CE 8A F3 0B 64 E8 + FF 15 7D F0 4C 01 3F 1D B5 2D 38 F2 80 53 07 70 + 0A C3 44 51 7C 0D 06 D1 2A 9C 24 F3 79 85 92 04 + F0 14 57 49 BC EC 50 74 C5 8E 6F 50 2C 8D 51 73 + DE +-------------------------------- + +:Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 +Result: + 3F C4 EA 9E 35 6E E4 5A 5D 20 68 ED 89 35 0D 37 + 22 D2 3C B4 29 20 CE AA 1F 46 D4 78 CA 25 99 83 + 6D 64 61 46 2E 89 B2 AF E6 0C 46 F2 8D DA C7 53 + 8E 8F 8B AD FE 05 F6 41 B8 3B 80 A0 43 5B D7 5F + CF 70 5C 23 49 C4 67 52 13 48 BD E4 A0 CB F7 A3 + 54 A7 AA 22 6C 64 FC F7 D1 A5 FD E9 07 D8 F0 56 + 47 1D DE 80 7D DF 13 B4 62 68 57 4B 80 00 D8 13 + F8 E8 83 37 99 95 31 FE 1F 48 A4 DF 46 1C DA 78 + BF 69 0E 15 06 35 03 38 4C 36 32 C0 5B 9B DB FE + 81 1C B8 89 DA 9C E6 76 94 15 76 2E D4 18 74 7F + FC 09 8A 2F 4A C0 51 23 4A 79 46 5B 29 5F CB C2 + 44 69 F1 2A BF 1C 9F 9B 60 E4 DD F4 B6 99 20 E9 + BD E6 33 41 D9 BD 76 BF 41 DC 0F 19 B0 A7 AC 5D + 95 E8 D0 F4 2A 7D 51 43 0D D0 4E 60 BD FB 58 0C + 18 06 94 47 29 A9 F6 08 42 80 77 90 77 F6 E9 C5 + BF B0 58 FA 49 6F FB 27 8C FA 49 4C 59 5B 75 51 + 61 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 +Result: + A3 4D C4 53 1A 6B 4C 3E D1 8A E0 16 CF 94 C4 30 + 62 FF 09 31 A3 DD 83 D5 AF BB 7C 75 CC FD 29 13 + 65 3B 0C AE AD DA 6D B3 AE BC 94 49 F9 F9 DB 74 + 44 9B 37 BB 32 CE BF 99 88 6F 0A 5E C5 0E ED 2A + D0 32 13 82 80 58 26 11 96 AC 9F C0 92 3A E4 D0 + 51 9D D9 A5 C8 B6 D4 B9 24 CF EE B6 6C 4B F6 33 + FE 6A D8 6D AB 8A 5C D9 62 3C BB 17 1F E9 F9 0A + 3D F1 A5 AE 11 25 A4 12 EE 39 92 F0 03 5C F8 77 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + 51 71 D1 01 2D 9B F9 6B 8E 10 A8 EE DC FE 50 EE + 99 EA 09 3E EF 3E AE 9D 14 70 80 3C 55 9D 72 40 + 9C E2 79 91 92 8D AA 7E DC 9B 6D 21 6B 2D 14 DF + 24 8A DC 54 4B 0F 77 70 84 F3 C0 C0 41 53 CE 4F + 65 DA DD B1 A0 CD FD 20 5A 3C BE 36 DD AA 17 48 + 81 C8 ED 06 A8 2B 49 FD E7 EA E2 CB 63 2D 77 BE + 5F 60 7D 1E 82 A7 90 7D 3D 9B 17 E1 5E 13 92 02 + 84 34 2C 76 6D 1F 6E 5F 34 DC 61 96 E2 FA E5 7C +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E +Result: + 66 80 D6 B8 55 C4 49 26 03 D1 D6 A0 98 32 B9 D2 + 7A 65 95 35 68 27 2C BB 30 56 EB 91 E9 15 9C 52 + 3B 68 F4 B2 EC A8 FA 7E 82 D2 38 EB FE 5B 3B AD + 15 FD F6 E5 84 18 6C 2C 98 DC BD 23 C9 FF F0 6F + 64 2D 96 2A 67 87 91 8C 24 51 AE 24 14 17 3C 87 + 82 21 9F AE 22 98 B0 27 B4 6B 32 7D E4 FA 16 32 + C1 71 AE C8 05 DF 66 4E 6B B0 2A 32 CC 36 D8 BC + DB 0F 79 E4 60 FE 44 0B 7A B4 97 CE B5 77 5C 97 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'random' + +Message data: + FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 + 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 + 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 + 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB + E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 + 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A + 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C + 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 + E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 + 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 + 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 + 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 + EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB + 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 + 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 + A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E + 4E +Result: + 6C D8 D0 FC EC D8 D6 69 88 BA B3 16 11 93 0A E4 + FD F9 1B 23 7B FB 04 FF F9 0D 22 8B 8D 9D 8D C6 + 6E 87 FE 3C 5C A9 78 28 A0 C0 7F 87 7B 54 43 70 + 2B DE AD F5 99 EF BB EE A6 4B E7 31 40 88 D0 1D + 65 F0 14 2D 41 02 D0 3E F0 B1 12 C7 EA BC 61 CC + 10 E3 DF 3B 26 E2 53 40 78 AF 48 68 2B 22 2F EC + CF BA 17 07 4E F3 1C 57 17 CE 2F 68 DE 77 2A 2E + 67 1F 1B D1 AE F5 33 16 75 FD 00 D3 85 FD CB 16 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 0 bits, data = 'random+MAC' + +Message data: + (none) +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 29 CF 94 9A FD 58 D8 69 63 94 42 29 AF 4D 33 50 + 95 E5 55 37 B8 A1 F4 A0 22 2E 9D 4F 2D BC D0 A7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 2D 4D C5 89 06 ED 89 60 96 A5 75 CA BB F0 EC E3 + 80 D4 B2 04 56 93 3A AD 3D 78 DD 28 07 54 3D 07 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + 89 E0 46 F9 E8 9A FA 60 5A D6 33 1E AE D5 E3 D0 + 8F C3 73 15 DC 9D A9 A8 1D 1D 1E F1 BD D3 37 03 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 3 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + FE A6 52 2D E6 C8 7C DE 44 6E 0A D2 67 C4 14 F7 + 97 12 2C EE C4 BF DB 33 1B 0F F4 18 2B 71 C3 06 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + A0 DA 95 B8 CF C3 07 49 61 A6 62 99 45 7A E7 04 + B6 C5 5C 67 E7 20 0C 62 B8 18 DB 8B E0 AC A1 DD +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 5 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 62 51 FB 02 D5 1B A6 B6 A4 0A 93 A4 03 E2 58 FB + 10 55 14 BC D9 ED 8D 05 22 FF BF 19 92 AD 4C 96 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 6 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + AC B7 69 48 74 29 E7 85 EA 97 D9 40 9C 3E 1F E4 + F6 87 1D 1D 71 53 80 F8 C0 CE A6 92 28 86 CD 7D +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 7 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + BB C6 EF 0E B7 25 45 73 B2 9D 74 DD D6 6F 52 3D + 48 90 6B 1C 30 75 44 4D 51 B5 FC 60 E5 55 08 35 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 8 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + E4 DE 5C 84 C1 34 1B D4 85 F7 3B 78 0A 3A 91 39 + C9 64 E4 76 1C 7B BC A4 DC C7 50 0F D6 E2 D8 AF +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 9 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 94 62 C7 88 17 BB 32 23 2E E1 19 85 5F CF E4 07 + 71 DD 61 19 C5 2D 09 51 C9 4C AA 87 3C 53 8C 32 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 10 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 17 AD E7 2B 6D 98 5D CE 0B B5 93 83 B0 F4 26 97 + 1B 22 89 09 68 4A E4 94 94 82 92 AF A3 50 AD 5A +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 32 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 08 C9 28 75 87 5C B8 99 F4 20 11 AE 31 5C A4 E9 + 54 DE FD C3 AC AD FF 9F 6B 92 B9 0C 74 F1 60 A4 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 64 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + A3 3B 83 3C 86 EA 22 F6 0E 46 59 3C FF 3D 42 BE + 79 78 E2 20 A4 78 56 21 DF 02 4D 32 42 59 E0 50 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 128 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + BB 80 E0 D8 EC 48 62 F0 F2 E3 34 83 08 DE 85 CB + 2B 4D 5E AC CF AD AB 84 61 D5 39 29 48 FD EB 5B +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 192 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + F4 06 44 16 8B 15 C8 AD B7 44 F6 13 0B C4 F4 76 + D1 43 BB 88 DB BB 91 BD 43 74 AA AB 0B A8 9F 27 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 255 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 55 74 45 03 07 47 F0 95 1F 18 80 92 86 A4 0B FE + DB 52 52 B4 42 DC 67 0E A9 47 C4 66 AD AE 2B 4B +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 256 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 34 58 B5 5E 04 92 49 4A 1F B2 AD 0F 4C 8B 2E DB + 39 FA 48 3C FD 8F 59 E7 E0 6F 60 3D 39 01 27 8C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 257 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + A6 31 31 CB 98 C1 ED 30 18 F0 00 5F D1 54 C7 21 + E0 31 8C 7E B8 55 76 60 7F 7A 7A 4C 7F 13 80 49 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 384 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + DD 62 02 49 9A 28 C0 CD C8 5B A5 85 D8 A7 02 9E + 1A 8E F5 7B 78 7A 6C C2 90 90 04 C0 4F E4 62 79 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 511 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + F6 03 DA 08 56 EC BA 0F BD 7F 92 A5 1B CF 64 C8 + B5 45 9E EF B7 04 C4 36 74 44 54 39 6E 91 3F 6D +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 512 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + F6 B7 47 9E 34 CC A2 37 09 1E 36 6F 29 90 13 E3 + 88 2A FE 0B EE 2A E5 B1 6D 1B C9 FC 40 6D C3 2E +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 513 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + FA EA 50 37 79 C6 46 B8 F3 4D 6D C2 E1 9F 34 96 + 8F 44 BE 51 BB A1 32 8C 01 A4 A4 1B 0D D7 40 36 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 768 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + F1 E1 3B EF D4 CF 4F FB 7B 9F 12 D1 E1 38 90 15 + 77 90 B9 14 AE A6 D1 24 97 EF 05 E0 2E CC 91 8E +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 09 FA BA 53 D3 DC 97 7F E3 DA C1 DB 40 D4 6E 04 + 3E 98 B5 C8 93 E6 21 EC 41 DE 33 8B 0C 16 03 9B +-------------------------------- + +:Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + FC 45 34 4B 5D CA 5C C4 8E 9E B1 80 1B B9 43 A9 + 84 F5 0B D1 +-------------------------------- + +:Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 06 85 2D 5B 7B B2 AE 8A DD 0E 03 5C C8 A2 2D D5 + 0A 32 E9 C8 60 9C A9 95 EF 26 BA E3 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + B5 11 8D F7 F3 70 5A 55 DF 47 26 A9 EC 68 15 98 + E7 C9 33 47 05 EC 1E 55 06 59 3E 0E 4F 9F 73 9F +-------------------------------- + +:Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + 62 53 2F 03 52 DA 98 87 90 E9 49 57 1E 06 05 C4 + C5 22 4D 7C A5 B6 69 F2 43 63 B6 12 BA 02 89 9B + 00 4B 40 A5 E0 27 33 D3 37 97 B6 01 03 F8 27 67 +-------------------------------- + +:Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 96 23 38 46 3F 2C 88 27 6B B3 F2 14 DA 4A 3B 64 + 9E 05 10 1E AA 26 47 F4 18 35 16 8F 01 F0 C8 11 + 79 E3 1C 29 5C CC 18 D0 51 09 79 B5 CC 8F 84 9F + AF DB A7 88 5F DC 51 F9 67 72 C1 FF 90 49 D6 46 +-------------------------------- + +:Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 48 6F 13 2B ED AC D5 82 6E A4 60 BF 56 93 6B B8 + 62 5A AA 20 1F 61 10 BD 22 4D 8D A1 7C E7 B8 96 + 9E 4A 25 90 1F F4 4A 86 E2 00 3D 68 74 53 5F F1 + 46 7A 00 05 B3 F6 31 98 66 96 9B 19 8A 70 78 0B + 5F E2 E6 D5 50 1F 00 DD 94 C5 FF 85 BA 34 AB 54 + ED DC 95 1D FF D4 5A F4 E3 55 58 14 6C 40 91 2C + DE EE 52 01 69 B0 86 C8 61 A6 46 45 88 F2 40 16 + 04 B8 E8 8F FD 1D 2E 97 2A AA 2E 2B ED 0B 6E DF +-------------------------------- + +:Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 6A C7 83 09 A7 49 89 82 4E B2 94 D8 92 83 DB F0 + 7F 56 F2 46 9A 52 78 FB B4 02 1C 81 0C 01 75 E6 + 7F +-------------------------------- + +:Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 81 91 6A 55 94 BC 47 13 07 E3 82 95 E5 B4 4F FA + B4 E3 C6 05 DC C1 05 2F 04 EF D4 6B 8A 4C 68 0B + 9A 12 76 AD 45 BB B3 E6 59 CE 01 8D 81 3A F9 EB + 6E 9E 58 AF 4D 50 9E FF 83 87 FD 85 FB 41 75 E7 + 3E +-------------------------------- + +:Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + 49 EC E4 FB E8 71 4E 16 27 9D BB F0 F3 18 3D 41 + 3E C8 8C 2B AD 40 7B 0C 36 E5 7B 76 A0 58 58 32 + 6D 2F 3F FC 05 F7 DF 49 AB 26 45 87 F2 0D B7 D0 + 44 9D 38 FA 0F 14 8E 5E 18 62 F5 5C 3A 20 67 8C + A8 14 19 07 5B 87 79 9D F2 BA 3A 92 34 E0 2E 1E + C7 75 44 DB 25 10 73 C6 34 36 F5 EE B2 D5 52 CA + A9 DF C0 72 59 DF 46 FE 24 37 83 B7 C7 95 05 76 + 3F 58 84 C8 D7 BF 53 09 9D 39 60 6D 07 9C C5 57 + CD +-------------------------------- + +:Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + D4 3E 3F E1 D4 B9 01 F2 27 C6 19 D2 8D F9 93 22 + A7 1E B2 54 BE 49 14 CE 0D 51 5C E5 F1 9E 39 28 + 4F A3 7E 8A 73 6A A0 0C 8D 36 88 1F C2 CF 19 87 + 1A 07 42 21 27 56 A1 F4 12 E6 EC B7 9E 4E 96 84 + 6E 20 77 5D 12 D0 52 E3 53 99 04 4C 3E B1 5A 9B + FE FA F1 EA 22 84 76 2B 61 0F 8A 2B 64 18 D3 FE + 39 40 60 05 E3 57 AF 8C 5D BA 9F CB E9 25 68 4C + F2 71 98 F7 95 BB E5 8B 8A 05 4B 9F 03 58 97 A6 + 87 70 DF 6B 6E 65 DC 17 D2 E1 51 F0 67 EA 7C 66 + 5D E9 16 31 6E 5C 9E 6C F8 65 A3 CE 9F 65 12 80 + 6F 7C A2 0A 3E 9B 8F E4 83 C4 B7 D9 C3 CF 7A 43 + 7F AB C2 AB 38 1F 5F 90 DE 1E B0 6D 7A 8C 85 40 + 31 FD 31 49 91 5C 2F AC 26 B4 09 DE B3 01 80 27 + D9 68 49 04 B5 2E B0 6B 66 0E E5 05 4E 29 3A B2 + F7 2D 24 FD A6 D0 CA 8B 6E FA E7 5A 9E 17 A0 DE + F4 9E DA 0F 68 F7 B4 95 C7 48 33 3A E3 08 1F 0C + 20 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 67 05 71 50 4B 14 02 DB 34 60 0E F5 D2 2F 27 BE + 15 D3 85 EF 63 ED DA 43 B7 02 1E 59 CC 51 25 45 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 16 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 +Result: + 33 84 43 72 A6 03 99 C1 29 1A E1 D7 2D 12 CB 06 + CD E1 6F 29 E8 17 70 B0 D3 C3 29 84 B6 36 F3 C7 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + A1 4A AB 45 48 0E 30 7E A6 08 92 62 02 70 7F 8E + 3D F6 DF 1F 91 9E 42 8D EA CF 22 4F A6 20 1F 61 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 + FD +MAC key = 33 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 +Result: + B4 1F FD 27 2C 7B 73 3C 90 7F AB 32 8F 7F DC 97 + 6E 77 3D C1 9C EE 08 B4 C7 BA 70 2E A2 68 4A A1 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 0 bits, data = 'random+MAC' + +Message data: + (none) +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 36 17 AF 3B 2C 17 0A 7B 15 03 63 DF D0 5A 21 E7 + 0E 3A B3 C5 63 1E 7F 74 54 C1 77 9C 45 D4 69 67 + 31 A1 50 AE 80 5B 69 BC 4F 68 93 C8 D8 3D 5F AD + 11 6C F7 53 33 DA F9 49 6B 12 C8 70 E2 5D 23 F4 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 6E 69 B5 AC 4A 5F 56 87 18 D8 7A 9C EE E8 38 44 + 7E 3A 12 D9 C0 1B C9 6E 2E B6 11 3E F8 8D B1 DF + FD 95 53 E9 5D 75 5D 38 C3 BD 58 70 F8 45 A3 C2 + 42 7E 29 6C 95 13 B1 3B D6 3C 89 1E 64 33 4A 0D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 9B B6 CC 19 0C 8F CE 11 39 BA 0B D4 D9 AE 68 C4 + 46 32 80 ED C6 88 3D 1F 71 B0 B0 7F D8 C9 75 71 + 66 A2 DF 16 83 FE 70 57 8B 87 67 29 E2 B7 8F 67 + 11 38 3F 6B 86 D8 5E 84 44 32 8D 59 61 A6 C1 91 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 3 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + AC 3F 42 2D 5D EB 1E DB DB C9 1C 74 07 FB EA B0 + A4 A6 2A 72 11 CF 08 80 4D B2 D9 36 7E A9 EB CE + 73 CA 50 3E F8 A7 C8 91 E8 C2 6C 20 A2 BB AD 4C + EA F7 C5 50 89 CF AC 9E 1F FF 34 5A 78 6A 35 E2 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 8B 4A D5 26 38 7A 3B 21 92 56 B0 5A BB B5 B6 19 + EF 81 12 CE E2 0B BA FB 91 6C 46 81 F8 6B B1 04 + 26 F6 F1 67 C5 E8 DD 91 AA F5 FB 74 EB CA F3 EF + BB 86 3B 32 66 44 25 6E B7 3B 28 A5 3F 9F 30 DA +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 5 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + A1 C9 B3 77 74 F6 29 55 E6 2E 7F EF 22 36 93 54 + 7E 97 EC 4E A6 14 E2 9B 0D 03 CB AB DB 93 95 D5 + 4A 0D 65 42 A4 32 64 F7 D9 D3 0E 3D 18 F2 B3 6B + B2 FE 27 94 B6 2F 94 D8 94 4B 0E E6 5C 54 E6 59 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 6 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 06 D5 98 E4 E1 C1 B2 FF BA 8A 56 CD 56 32 45 E9 + F7 C2 8B B0 8D 24 15 75 B6 4C B1 0E 84 00 23 03 + 57 13 23 77 9F B1 EB BA 85 AD D6 9E C7 ED D5 F5 + 75 D0 EF D0 2B C7 C5 40 6C 6C 4F 3A 39 57 72 D8 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 7 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 39 8C 17 37 7F 8A B3 44 8E 45 18 BA 40 E6 C1 85 + 2A 32 10 65 48 D2 D2 BB 9D 7E 2F 11 F4 D9 D7 26 + 66 45 2E E0 92 D8 0E 5E A4 AE 41 17 97 25 6A 99 + D9 56 64 2E C7 AD CE 5D F4 36 A4 51 23 A9 AC 79 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 65 8A 57 64 E9 AA 60 9B FA F8 66 55 23 F8 CD 0D + 01 7F F6 6F 61 06 E1 09 A1 45 EB 63 8B EB 15 00 + 05 ED 5C B7 88 68 F1 A9 E4 F8 7F BD E3 22 F2 2D + 08 B7 5C 9E C7 4F D6 6D 14 64 4E 11 4B CF 14 10 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 9 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 8F 77 4D E9 46 A7 31 21 09 B8 0C AF E6 3A 18 B8 + 3B DB 23 FC D3 FB BD 5F E2 4B 6A 38 C3 15 99 99 + 62 3C 46 7D FA BE AD 23 4D 8A B7 F0 84 D0 B4 D9 + 91 E3 42 82 76 90 2E E4 10 0E F0 77 14 7A 26 83 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 10 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 35 77 01 9D B3 C1 21 AC 1C E2 05 50 E0 3A 12 F7 + 30 8B EE 44 3D 2B 73 99 AF 63 F0 A8 CF 83 0D 47 + F3 4C 9E 97 30 06 88 CB 91 9B 47 2A 38 E7 26 26 + 93 B7 F8 07 36 89 4B A0 0D 39 61 C6 DE 55 BB C4 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 32 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 4A 79 65 28 0B 9F E8 F3 59 BC 43 83 F6 E2 05 A0 + 4B F6 F7 FB 30 17 8F 14 19 26 B9 6D 71 92 4C F1 + FD 1E 07 85 5F 68 69 27 80 DA 7C 83 7C 4B 4A AE + 78 1B 94 4D BE 86 09 11 BF AC 07 0E 2E F1 70 B5 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 64 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 9A A7 02 40 C9 20 5C B8 C8 5D C6 F1 7C 3F C3 7A + D3 95 DB A4 54 43 ED E2 53 6F 01 43 03 60 E7 7B + 91 29 63 7B D6 0E 0F A0 53 E0 40 B1 07 C8 AB 2D + 34 3E 3C D5 38 C9 69 73 63 C7 D9 6E 20 9F 24 88 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 128 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 43 F0 38 A9 13 CB 20 97 BE 0F 90 BE 13 A4 67 11 + F5 7F B0 77 1A 84 B1 E9 F4 73 9C 52 3E F0 51 91 + DA 13 DD 6F 75 39 93 FD 78 F7 D5 03 EF 46 8A 72 + E6 20 4E 98 91 F2 8B D9 FF E0 2E F4 2A 1E 14 31 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 192 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + F3 01 05 39 4D 8E 5C 39 6B 29 53 2A C5 8C 59 72 + 9A 4B D9 56 14 1A 8F E8 92 17 98 8C 78 64 30 C3 + 42 F8 12 80 FE 45 16 06 A2 48 B5 A5 2D 44 ED 63 + E9 3A A7 E1 4E CE 14 B7 6E BE AD 68 1A 20 8E 8A +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 255 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 19 52 D8 F8 F1 AC CE A4 9D 92 A2 99 BC 9C B0 10 + F9 AB 0A 8A 4A 35 44 1B 0B 65 FE 5A 23 BA 98 38 + 24 52 B4 D4 CB 7B B6 F4 6D 8C 03 8F CF BD 9C 0A + 7D 13 49 C7 94 0C 61 22 AE 00 1F 62 36 59 6B C6 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 256 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 31 C6 C4 FD 74 F1 33 F3 CC 37 3E FC C5 65 78 F2 + 8B 5A 8F D6 FD 5C 2B 1C B8 7A 04 CE 21 61 AB E0 + 78 D7 39 3E 83 B9 F1 11 4F 79 86 BC 6D F8 73 B4 + 92 E0 53 8D 3B D3 DE DC AA 0D 3D 4B FA FB 91 C8 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 257 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 80 F3 9D 25 33 63 11 25 E6 A3 5C FC C5 3E BA 72 + 3B A2 08 93 CF FE AD 48 E2 C8 1A DE CE 00 FE 1B + 2D 09 8D 02 7C AB B8 11 FF B8 12 FD DE D7 B6 04 + 75 D9 C4 23 15 79 2B D6 44 30 A5 FA 25 E2 DC CF +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 384 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 5E 8C 81 87 0F A7 C6 30 DB F9 BC B9 D2 92 C6 B3 + 28 61 C7 D9 D9 95 F8 6F 36 D7 97 91 7B 8A D0 01 + 57 C5 79 3B 9A 05 12 49 19 A2 70 97 D5 A8 0D 01 + 0E 23 6D 20 EE 70 DD DD 8B F3 02 74 AF CC 4C 22 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 511 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 87 69 8C 97 AB 3C 1D CB 58 BD D7 BD 99 F2 70 E3 + 39 1B B4 B8 88 D1 49 74 91 B3 E1 F0 AA 60 22 60 + 2D 4E 5E A3 9D 74 05 C0 B3 E1 47 F1 3D 4A 75 1D + 0D 5C 1E 1F EC 60 DB 52 A7 54 47 76 E8 F4 F3 46 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 512 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 0A C8 B4 B7 3A 46 E1 33 8D 51 71 B8 19 5F 71 D3 + F9 70 BF DA 88 48 7A 4D 1D E2 48 89 B3 20 52 48 + 4D B3 64 3A A0 10 6B 62 47 22 CE 12 89 EF CC 33 + 6A 82 4A 62 25 DC 5E 4C C3 9F F7 0E 6B B5 F9 10 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 513 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + DF EE FE 01 D8 D8 73 0A 05 90 5A 76 62 D1 9C 00 + 92 48 69 14 E3 EF 1B C8 35 DC 74 C5 12 DC 28 C6 + B8 2E 05 70 86 5F A7 23 28 11 A8 C0 A9 D6 68 20 + B1 E9 91 1D 50 51 7D F4 C0 77 C9 21 3C D6 78 15 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 768 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 16 09 95 10 93 8E B6 85 06 7D 55 C6 14 36 DC 25 + AB 87 B7 CC 5D FB BA C4 69 8A 51 D9 D8 F1 97 2F + CE A0 AC DE 44 68 5A D4 E5 A3 85 1D 79 16 52 29 + A9 EE 8F 4E 37 1D EB 02 84 5E 99 37 60 B2 56 0C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + F4 18 9F 80 47 CC F9 9F AD FF 6F F2 AC 88 B4 3B + A4 AB 0A 7C 0E 21 E9 6F 0E 71 27 D5 5F 37 2F B3 + B3 8B 4C D5 3B 53 8C D6 49 F2 E2 C1 8B 3E F2 41 + 0C C8 BA F9 F6 51 BB 6E EB AC 2A 55 73 5D B2 05 +-------------------------------- + +:Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + CD D7 5A 47 1D D4 1C 9F 8A 38 7F AA 12 BC 98 67 + F4 D5 8A 46 +-------------------------------- + +:Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 8D 60 57 25 07 FE 40 94 30 05 38 84 4C CB C1 A1 + 69 B9 82 40 8A C7 E6 20 26 59 D9 80 +-------------------------------- + +:Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 43 3E 4C C1 50 02 8C 35 F9 89 67 FC 39 52 61 D4 + E8 AD CF 05 AD AC DB 1E B9 96 CD A1 14 39 86 0F +-------------------------------- + +:Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 20 46 36 45 BB 12 7C 66 EC AA A0 28 E8 95 D8 B2 + 6C E8 8C 70 4D 5E B8 06 78 AC 2F DD 78 5F 8E 9E + 6E 5E F1 97 A8 E1 C6 CE 70 42 51 C3 E0 FC BC EC +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 39 5E 73 D5 1B FB 60 F2 1B 69 48 E3 0D 6E 00 C5 + 43 3B 74 0C 99 EE B5 A1 94 35 CC BC E9 C4 D6 34 + 80 59 21 71 91 F9 6F 9C D1 11 D3 49 25 A1 90 0E + 08 2A 93 69 F1 D2 5C 2F 20 BD DF 21 2A 95 0B E5 +-------------------------------- + +:Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + 3C 4E F7 49 44 5B C7 60 93 C0 FE FA BB 24 67 FD + 40 8C E7 E2 B0 31 9D 0A 27 10 E6 91 1A BD 58 C1 + 57 9D 6E 72 8A 9C 10 C2 F8 FD 7F 30 02 0A 5F 19 + A4 17 7C 67 F6 F3 19 0B AD 80 AA 9B A2 5D E3 08 + 01 68 AD 1E 24 0C EC C5 E9 9C 51 5F 12 A8 2F 65 + 57 02 FD 67 8A 60 7E A6 20 72 A5 5C FC D4 B3 4E + 96 1C B4 69 09 00 3A 60 FE B8 6D AE 3D 4D 75 44 + 56 59 1B 57 5D 76 14 AB A9 76 B3 C9 0C D8 51 E3 +-------------------------------- + +:Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 19 64 A8 A0 65 C4 B5 AE 3F 0E C3 FB 39 19 A7 92 + 49 7D DD F5 75 FD BD BA 4E 2E E4 83 AF A5 10 50 + 5B +-------------------------------- + +:Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + CC 89 83 7F D5 29 DE 13 61 CE 96 0F F4 AA 5D 1E + D2 B1 EB 73 73 35 BB 5B 24 B2 39 00 33 8C 7C D7 + 76 7C 2B D8 63 1A 27 3E C3 0A 07 91 F6 B6 75 0E + 3C 4B E7 EB F0 B7 EB AE 2F 21 DB DE 12 E0 CE 67 + 53 +-------------------------------- + +:Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + E7 73 60 2E FB 55 55 C2 2B 28 CE AB 57 51 9A 04 + A2 11 FD 63 1B C9 D3 D4 37 92 6E AF 5A 42 74 05 + 96 25 F6 24 70 40 A4 64 EE 91 44 07 DC 6B 27 B3 + 6E A8 C4 6A 4F D6 08 3E 83 26 31 34 B2 67 69 D7 + A2 E9 D8 B7 84 6E CC 4D C6 FA 60 41 31 A6 2F 6F + 1B AC D0 D1 E0 A9 65 8C D5 91 5C 10 15 37 CD 2A + 8D 2D 3B D7 79 43 4E AF 59 E6 73 B4 65 00 F4 A5 + 5F 58 65 CD A1 2E 0A 26 DD A8 B3 A4 71 05 2F B4 + 4F +-------------------------------- + +:Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + B6 9F 77 0F 26 7D 78 5C 8A 3B 79 4F 56 E1 27 B8 + F9 E2 EA B9 B3 4C 7D EC E1 38 C7 EC C0 0A CF E7 + 27 7A B5 D3 00 D9 56 52 52 5B 7B 1F 99 48 D2 92 + C6 46 C6 A6 87 0D 42 5D E7 D9 29 61 0F EF 34 6C + 2B 8F 75 C3 AE C7 B7 7E 52 10 F7 CE 72 61 D8 3F + AF 03 1C 45 2A 9F D3 5C 47 A4 52 A7 C3 FE 2C 05 + 67 E7 4E 61 EC 99 86 2F AF 74 8E 9A 4C 2B 40 EF + CF EC 37 63 AB 99 90 5E 5E BE 3D F5 5D 5E 52 3F + DB 2B C7 75 B4 9B A5 82 FA C4 51 FC 88 9A 47 70 + 5D 77 40 26 A8 AF 7F D4 A1 D8 B3 1A 2B E7 CD 84 + B8 90 91 5C 66 FE E0 48 79 96 E0 37 C9 D2 74 18 + E7 51 E7 62 B5 36 85 76 DC B9 58 1D C3 BB 6D 59 + 2C 69 7E 7A AB 73 D2 06 F1 80 19 8B B5 10 57 FF + 84 8F 69 44 34 7C 31 BD 87 CD 5D 32 E0 45 54 2A + 30 32 87 2B FC 6F BD 56 37 30 78 E2 99 80 9A 6F + BA D9 35 DD FE 46 AD 76 8B 0C 1C 53 5F EF 96 CA + 00 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 +MAC key = 65 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 +Result: + FC 99 33 C1 76 8F 6C AF DD 0A 30 5A 5A DB 6B D6 + B9 B8 CD B2 1F 67 DA 73 0D 87 63 0D DD B9 9A 60 + B9 2F 30 B2 EC A4 9A 46 AC 9E E6 68 B9 59 04 1B + 68 35 E9 A3 5A B9 6D CA B3 3F 1E C7 0B E3 19 77 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + CC F6 F5 2E DC 1D B9 41 AB 11 E4 12 A6 A7 41 3B + 86 AE 35 A2 55 B9 B1 AA FF 70 6C D8 88 A5 C6 DF + C8 DA 2F 95 8A 8E DF 2A B1 91 FC 40 07 AC 25 FB + CC 37 D4 BE 23 53 D0 4C 00 3C BE 32 56 F1 C0 ED +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + A6 CC 71 E1 80 DE 7C A6 8C 51 F6 3C F8 61 DF 52 + 25 E9 24 75 26 D5 F8 4B 64 3C 12 6F FD 0E A5 8A + 12 74 BB 6A CC 2E 5B 37 6B 27 75 43 3C 76 A8 B8 + F8 FA 67 22 CB FD A7 EA 5C E4 B5 7B 93 D4 27 6B +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 + FD +MAC key = 32 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E +Result: + 26 CE BB 40 C0 54 EE 30 C8 F9 37 6D 25 72 F5 2D + BD 6B C2 F5 17 8A 5C 05 F3 E3 30 E4 45 44 D0 F6 + E9 8A C0 AC F9 2A 5E 62 00 1D 7F 2D 8F 85 9D 4C + 85 5A 56 BF BA 39 B9 3B AC 11 B9 56 EF 7C 3C E1 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'random+MAC' + +Message data: + (none) +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + 4A C9 B6 2E 25 27 E0 CA 08 A6 5E 25 2F 6A EC 80 + F8 CA 50 10 B7 F5 2F A5 7C 2D 30 B8 B0 35 B5 11 + 7A 73 80 B6 F0 BC 1B 3E 93 3F D4 48 FE E4 A7 0A + B5 03 1A 94 90 36 86 C7 2E 94 17 4E 79 6F 74 A2 + 18 04 9C D2 56 EB 60 EB 90 5F 90 C0 D8 36 91 58 + 24 75 1C 16 64 B1 79 EE 64 49 8D 05 C8 BE 5A 88 + 40 23 0F 93 1E D4 CE F3 28 34 9C BB 94 B7 9D 45 + 76 8D 7D 8D 18 CE EF B6 58 22 CB 73 C5 0E 38 CF +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 65 8B 8E E5 EC 1A D1 73 2D 19 03 61 90 C7 23 01 + A4 CC BC 1F E8 AE 98 ED A2 55 C7 0C A7 6C C7 2F + 16 5D DF 00 D6 F0 1B CF 10 92 AE FF F5 A8 BC 7E + 72 FD 28 67 5F 0C F1 FA 5F 96 D0 74 E3 9D 65 7D + 68 BE DE 6D FA 6A B2 F2 B0 E1 9D 1E 2B C6 A0 CE + C9 0F 1C 64 BD 6A A1 15 7B 32 E2 2D A2 CB 9F 88 + E4 7B 35 41 C2 0D D1 0D 51 98 86 D2 ED 26 2B 9F + 8D 0D 80 54 D6 0E 2D 6E A1 49 0F 78 6D 14 24 9B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + C3 5E BB 60 D4 42 7B B4 76 24 3C F5 3F 61 4C AF + EE 45 45 90 19 23 3D 48 63 AA B7 00 8A 63 2B 12 + 00 5F A2 19 65 20 BA A9 9D 7A 60 C2 B2 E4 9A A1 + F9 A5 C5 78 46 CB 16 0B EC DB 3B 93 DC 76 B6 77 + 5A EF 35 9C AF E4 9C F9 B6 B6 2C 91 BA 99 08 86 + 77 6C 89 BE 78 A3 C3 B3 EB 6A 2A A4 B4 5D 4A 66 + C4 8E 6B DE 57 10 6C EF 68 FA 13 DB F1 FF 1D 50 + DF 21 06 5B 12 CA D1 8B BC D6 B4 37 65 3E D3 B0 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 3D C3 38 8C B5 15 BE 28 31 B4 F1 98 BB 4F 08 58 + 98 24 73 DB 75 E9 12 0D 9E 49 D0 56 0A F7 AF 71 + 38 11 A1 C8 A7 B2 10 26 6D DA E9 C3 FC A2 1C A1 + 9A F0 DD 2E 97 2B EA C2 40 1D 86 EC E4 FA 76 D7 + AC DA BB 9A 88 D0 67 3B 7F 66 D8 F4 02 F6 33 54 + 72 89 21 ED 0A 7E 0A D7 83 44 C8 85 CE C5 BB BA + DA C8 20 51 BB 29 37 EE DF A9 F6 7B 3A AF 65 BF + F9 06 7A 1C 4A 63 EF 5C 1C DD F2 6A F8 1D C6 E2 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 11 FE 66 FF 60 06 A9 22 1F DB 4C 12 F3 60 EB 17 + 47 6D BB 5D 0E 2A 43 C1 23 E1 91 E8 80 95 99 53 + 18 22 E5 53 2E 35 46 BD 33 7E B1 81 C4 8F EE 61 + 4E 15 69 96 AA 82 E2 C3 3C 52 00 8D 90 EF DA 4B + 5B 55 D3 6A 83 9F 5D 46 56 4B 69 48 D3 B2 A7 4A + E1 7B 37 2D 93 C7 CC 4B 29 DC 14 02 21 DD 8F 12 + FD 26 A8 B4 06 72 A9 6A DF BB B3 1A 46 64 79 F2 + DE A9 69 FB 9B 6F 6E 55 FA EB AF C6 3D FE 96 4D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + BD 13 18 7D DF BF 70 93 71 A6 2B EF A6 C8 78 F6 + CC 13 A2 34 61 50 A7 E3 ED A3 7B 5A D1 24 F0 E2 + AC F1 11 B7 D7 51 EF 9A A2 2A 39 31 AC 11 A3 12 + 4B BC 93 B4 42 DD D3 A7 D7 A3 11 27 6F 4C 8B FE + 13 22 56 18 3E 0C CD 6A AF B4 45 EF 92 70 C8 80 + BA AF C6 C5 AC B0 4B E1 2A 60 C0 C0 7B A7 89 18 + 9D A2 59 90 2E FD 3F 43 9A A2 3D 9E E1 53 1B FA + E4 D4 B4 9B BA 14 FB 83 8E 87 06 70 1E 8E DE 56 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 53 36 26 AC F0 A6 C3 B6 F0 35 31 C4 9B B4 11 56 + 05 6C 83 3F 19 70 F4 C2 8E 62 D5 87 BE EC C5 57 + F6 DB 22 97 1A 99 1D 86 14 6C 35 58 4B 14 E2 3D + A1 A3 29 E0 BD 61 46 DA E2 5B 95 B4 20 0F 3D AC + BF 3D C5 12 FB 09 A5 76 C7 17 39 B8 7B 48 DE 83 + 7A 2A 6B 43 97 69 98 FA E1 15 1A 4E 2F 1B 1E CC + DB B7 36 CD DE 1E A7 C1 29 45 10 41 36 98 A3 21 + CD A1 C4 62 79 39 56 05 D4 2B 28 30 DD D2 DA 5F +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + A9 FF 45 A5 D8 1A 42 9D 6C 5A 9F 11 11 9A 54 11 + 34 B5 0A 83 72 AC E2 C6 B0 73 3E 2E BB FE AB 6E + 48 0D ED 1B 0D 80 6A D0 D5 B8 B4 8B 4E 06 30 9D + 6D B2 D9 B8 CE 45 97 55 69 4D 3A F0 BF D7 7A F3 + E1 8B 89 D1 55 4F 5D E4 45 EE 8F EA 0B 05 57 84 + C8 9D 9E 04 1B 48 A6 34 A5 70 46 23 38 EA 38 E1 + 64 D7 58 82 20 28 D6 94 2B 1B B6 C5 62 F5 77 08 + DC 02 72 B5 26 AB F5 3E 50 00 9A 3B B6 31 CA 97 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'random+MAC' + +Message data: + D3 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + EC F0 96 D2 72 D2 3A 92 ED 64 AE 8C 59 B6 07 C1 + C4 9C 4B 00 3D A6 36 A2 93 E8 27 61 B4 F4 E9 1E + ED 19 53 8B F7 06 3B F2 51 3C DF 66 A1 CC DB B4 + E2 9A 14 BC ED E6 10 55 9F 2E 4F 9B A7 22 75 00 + 0A 44 E9 AD EF 7B 36 99 7B 6A 70 1B F7 73 84 77 + 9A C6 BB 4E E2 2C 2C 3F 94 4E 1D A9 EA 94 E5 A3 + E7 90 F2 27 56 8D 3A 4B 90 42 20 B2 18 C9 A1 75 + 15 29 A0 C3 A9 68 B6 EE 88 2E 35 B5 34 D7 DB F5 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 34 BC E5 B8 9A FC 29 65 E9 8B C4 C7 72 E1 C4 76 + 88 DE 89 77 30 D1 2D 66 AF 0F A6 81 29 2D F6 45 + FB 73 61 50 1C 52 61 6E 95 DA 20 10 1D 9B D4 21 + 6E B6 3B 61 91 B5 58 9C E8 A4 8D 02 B7 74 0F 4D + A1 1F C9 B0 4B F3 3A 51 7F F9 8A 70 AC 82 39 16 + 20 E8 A0 42 97 01 6F 5B CE A3 E8 EC 4C 8A 3C 01 + C4 1E 8D 44 BD CA F5 97 C3 16 2D AD 5A C7 C4 B1 + 16 2D 0E F1 80 DD 69 BC 58 57 E2 72 DD 64 8E 29 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'random+MAC' + +Message data: + D3 09 +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + 30 DD C8 C0 08 93 9D 11 A5 3E 57 81 2E 8E 46 DE + B3 ED 48 57 C8 2E D3 6E 7A B4 2C F2 8C 56 43 AB + EE 46 34 4A 9C 68 FA 3C D7 66 0C E6 4C 59 60 3D + 60 3A 44 47 9F 3B A0 F8 00 19 DB 2A E0 6F 30 8F + A6 41 2B FB 3D AE 3D E3 55 E6 9C D5 19 06 0B CB + C6 18 82 36 CB DD 86 CD 9F A7 E9 4E 26 F5 93 7A + 64 38 F5 6E 3B 05 02 44 64 ED 91 3F 92 0D B5 1D + 4D CA 98 02 96 36 42 18 FE 96 58 60 82 86 76 43 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + BD 37 97 30 34 F8 D6 83 BE 92 6D 4C CF 09 EA 11 + E2 63 DE 49 38 AC 22 6F F6 13 C6 CD BE A3 34 FE + EB 8D 05 D2 8D E9 5F 0F 87 91 D3 BF 7E F0 3B 96 + B3 D3 CD 56 C8 3C 96 18 C2 85 06 FD 23 F7 67 2C + F5 F2 09 5B 22 7A 3E 75 9D F5 CF DC 64 BC E9 84 + 99 57 D2 97 6A C0 1E E1 73 87 E0 05 10 CB 69 1B + EA F9 CC BB 8F 9E 96 CB AF 71 55 70 DA D2 07 8E + 08 4A 08 99 44 D1 EA CF 5C F7 0C CD CD 66 D0 8F +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 0E 1E FB 6C F0 AE 2F F6 27 DD 2E EC 50 42 32 0F + 10 30 E3 E8 77 1C C1 24 38 CA C6 DD 78 6C 6F B7 + B8 B8 69 31 5D D1 6C 01 D7 71 C4 2D 88 09 41 41 + 40 C0 72 C8 5C A3 25 7D B1 45 01 EF 03 B5 C0 D5 + 83 47 BB 62 84 7C B2 F2 A7 49 3D 4C B0 2D 7F 7C + 70 D3 B2 D4 A3 90 BC E5 5C DD 33 0B 0A 35 9B 23 + DF 2F 59 57 7D 10 1D 20 87 3B 4F 3B B3 F2 7D C2 + 9C AD F1 50 CA BB 13 20 99 86 CA CA 54 20 CB 92 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 10 AF EF FE BE F1 E8 CA 66 15 00 4D 10 55 A9 80 + 5F 7C E2 3E B5 5B 44 B8 52 C1 5A 0F 9C 46 FD 03 + 09 AC 8A A0 2F C2 73 9F 42 38 D0 C3 48 42 C6 B8 + 61 BA 8A 82 A7 D8 B8 14 46 EA FE F7 82 65 58 84 + 2C 65 C5 4D E8 E4 6F E3 0F 96 AE 9D E0 DD F2 EC + 2B D5 DF E8 AD 2E 7B 6B D0 68 F5 F1 8A 33 F8 53 + 68 9D DF 67 73 FD 1C D8 39 FD ED 3C 41 8D 0C 4A + DB 93 D0 A3 54 29 BD 58 3F 5F B8 1A EB F9 44 C6 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 38 3A 10 C2 D2 E9 2C 5E 6F FB 2D EA B6 0E F1 1A + 29 1E 3D 58 F7 B8 E6 14 15 79 53 AD 36 D7 38 2B + 40 8E F2 64 5B 81 61 3B 39 1C 92 F1 A2 2E CA 2A + 00 13 0A 38 FF A2 18 6B A3 92 C9 38 F9 AD 3C 44 + 27 63 D8 87 E7 96 85 E3 E7 60 D1 6D 1C 87 5F F5 + 19 D4 0E A3 44 B3 71 83 0F A1 D2 96 A3 45 EE EE + A5 95 DF 1A E5 97 20 43 0B 86 3A B9 88 1C 41 26 + B8 D5 55 CA DA CC 18 FB 5B 86 42 01 BF A7 27 F8 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + 1C F5 22 4A 1D 50 DF F9 5D F2 CD BE 27 3D 5F 49 + 05 83 25 9E E2 16 E9 1E E7 48 D7 C0 B3 23 EA 52 + 89 C4 90 18 9F CE 20 AE 02 DC 6B B4 3D ED 14 9D + DF D0 3F 53 01 18 57 A8 FC 1C 67 61 26 1A B6 C6 + CB F7 85 91 AB D7 95 BA ED 6A 91 9C 2D 57 B8 FB + 98 B6 E1 96 DF 32 9E 1C A7 89 76 93 A4 16 32 92 + 7A 1E 41 BC 06 4D B1 BD 73 FF 2E 4C 11 A6 3F AD + DE 95 AE FC 9D AD 01 E7 67 7F C8 0B 61 8E 05 47 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 5D AD 35 4C E9 44 34 1D 92 D4 E8 EF B5 0E 21 E5 + 74 60 7D 4F 13 5C 2C 2D 37 29 D9 92 15 71 D8 81 + 4F B4 4E 9F 76 E8 36 54 1F E5 C0 1B CE 50 9B 2E + 74 A3 ED 17 DF 59 2A C7 31 0E BD EC D3 DF 3B 0F + D6 4A 22 43 0B E1 BA 57 89 33 7F E6 37 EA F0 81 + 42 94 3E 83 8F 5A E5 C2 A4 07 AF 0E 41 65 F2 F2 + F2 44 F6 85 20 94 97 92 8B 3F FF 57 E8 A0 F3 F8 + A1 23 92 71 FB CF EC 70 41 D7 1F 51 83 5C 96 A7 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 69 ED 35 93 23 32 8D 6A 97 CB 56 65 C9 40 35 CD + C8 F9 12 8D AF 18 8B 24 67 77 0E AF DF 88 D1 28 + 16 0D 67 2C 1E 31 9C F2 C4 6B 77 15 BE 5C 2A 74 + ED 7D FF BF A0 9F 3F D2 36 0C 7D F6 05 04 60 1E + ED 15 2D 19 A8 9A 95 34 5D C3 EE 74 58 26 D8 47 + 8B EF D5 58 79 39 F3 B0 A2 6E 74 A1 42 CD DB 90 + D5 B9 AB AA 1A 9B BE 1E 0D B7 59 CD 9F 9C BF 9A + AF 05 08 47 68 8C 82 BB 3B F4 87 E9 F1 AD F4 FD +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 3D 6C 44 50 32 96 61 90 08 DA CA 1C 1F 5C 40 53 + A4 2F E3 95 91 7E 4E AF AC AF 09 A8 76 44 7B 66 + DD 43 0D 37 86 7E B2 C2 E8 52 0E A9 EA 0D 4F 43 + E8 7D AE 25 03 FA 3D D5 EE 5E C2 A1 83 C1 74 DA + D2 01 20 40 FE BD B0 8A F0 9E 23 18 63 08 94 DD + 44 25 01 66 50 FF 2A 78 1B 3C E1 D6 5A 0C EA B4 + 18 B8 49 5B DB C5 57 A0 60 A5 CF 1F 15 0B 7D FC + A4 B6 E7 ED 4E 4C 6B 56 82 61 69 F3 E6 93 C0 3D +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 67 57 12 23 15 CC C3 81 9D AF 61 86 3D 45 BB E1 + 1E BD 0E 3C D0 F5 B5 16 E1 F4 92 AB D3 80 6E FD + 9C B5 76 12 7E 6A 29 B6 53 39 B6 F4 C7 79 0F 5C + A2 AE 67 BC BF 99 8A 44 89 9F A2 B3 90 E9 56 10 + 01 CC EF A4 89 08 82 B8 76 BB A0 EA F4 34 E1 C8 + BA 83 6D 8F DE 30 FC B5 17 16 BC EB 24 FC A7 DC + 34 7B CB 92 F5 87 3D B1 64 E4 58 40 6F D3 EB 6A + A5 A8 76 DE 8C 00 42 28 12 64 0D C8 05 19 96 83 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + 07 AE FC ED 89 0F F0 A8 4C 76 25 30 E3 C4 CE 57 + 2C 31 CF 91 90 36 09 DA C0 F7 5A 66 A3 26 F5 45 + CB 52 F9 8D DD AD BE 8B BF E4 A5 0F C5 5D 78 19 + ED 92 A5 C1 A7 7A 07 D1 19 DC E3 AD 90 48 D1 CE + E8 6E D4 A8 27 A8 DE 5D 84 1D A8 33 BB AD CF A2 + 18 DF 10 64 4D 0D C5 67 06 5F 50 B3 E7 3A 8E A3 + BA 91 E3 A2 5D 7A 74 C2 F1 B6 02 E4 46 7E 29 A6 + AB FC FE 7E D8 31 EF CF 9B 98 01 42 F3 3C 43 4C +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 7A 32 90 92 BE 54 8E 4D 83 12 41 BC B4 67 E5 63 + 5F 23 2C C8 36 48 DD 85 05 FA 6F 8F EF 9D 4B 79 + 1D D2 BE 40 C8 21 3C 5D 7B 0E 0C A7 32 5D 84 1C + 8A BC 28 0E 53 00 93 52 74 32 AE E7 FF 17 DC 10 + F1 99 4F D5 96 3A B8 33 73 FC 7C 9F 80 B8 59 11 + 86 A0 DE 8C 63 FC A4 C6 02 BF E9 BD CC 88 F7 E5 + 0E 1A 4A FB BD 82 1D AA 95 D6 4F F4 AE 16 52 87 + 19 AA E3 9A D8 A9 0D 6B DA 18 E4 62 07 B2 90 8A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 0D 10 9F 9C 1C 92 01 05 6F C0 1B 8C 83 2E AC 6F + BA 07 14 EF 4C FC 5C 6C B2 52 23 46 53 22 C3 B2 + 0D EF E3 EC A4 93 BB 93 BA D2 4D 22 71 DA A1 67 + 21 4D 5F D7 46 42 28 D5 AB 3C A2 F6 CF 1E D4 8D + 34 55 10 29 26 AB 23 B1 96 6D 22 8E 67 01 46 09 + 73 E2 49 0C F3 B5 70 0C DE A0 76 02 F9 61 40 49 + B5 62 25 62 56 FD BB 70 2C A4 3E A6 EE FE 55 C7 + BA 3E 0C 80 A2 99 5B 8F 76 81 0F EC D8 32 7B 68 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 31 80 17 8F 06 9A 23 42 CE 93 CF D5 8F 30 BA 88 + 35 DE BE 35 57 47 1B 30 71 DE EE 49 51 84 B0 AC + BF 23 0F 97 91 C5 78 EC BC 97 A4 06 EE D6 15 C5 + 9B A8 B3 F2 78 63 A9 5B 89 81 86 2D 7A 1D E7 77 + D6 34 3D A5 82 A0 A1 0E B8 20 46 57 30 A3 02 03 + B6 B7 68 A1 CE 06 8F 06 1D 1A 9F AF E1 C2 5C 64 + 8C DA 74 0B 36 BC 98 FE DD 9B 5D 2F 16 6E 06 DF + E0 62 BA 3F 88 5A 39 75 B8 9B 6C 97 F2 64 BF F7 +-------------------------------- + +:Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 0F B2 67 3C BE F0 26 E0 DC 27 AA CD 3B 0C 1B 01 + 54 E4 B8 E2 +-------------------------------- + +:Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + AE 6B CF 8D E8 49 61 12 8B 0E 84 1C 65 5B C4 4D + 52 DC 3E FE 2A D9 FC 7B D4 41 F7 4A +-------------------------------- + +:Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 9E F7 FB 74 C6 BC 7C ED B0 26 60 7C 15 3C 65 0C + DB CF 2F C0 F5 6A 2F B6 E2 DE F3 93 66 A6 08 DD +-------------------------------- + +:Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 64 7B 90 0D E3 5B 1C 97 1E A2 1A 65 31 3A ED 0E + 91 06 6E 2F 2D 4B 68 CC 16 79 36 F2 CE 06 64 05 + 69 FD 2D DC 46 34 8D B7 3D E9 C4 63 EC 21 D3 6B +-------------------------------- + +:Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 83 16 7F 63 AC 8A 2C E2 30 63 79 D9 73 71 C2 5D + 49 38 BA A3 F1 9E D0 A1 F0 AF 8B C9 A9 CC 08 3C + 00 7D 25 C5 2C 5B EF 9B 5A 4F 38 2A A0 07 EA C0 + F2 BF B5 19 48 6D F3 44 23 1B 41 3F 9B 2B 4E 28 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 0C 46 1C 75 6F B6 76 D9 15 01 9C CD A2 90 4C 5B + DF DC 39 4D B0 F4 98 7E 1C 8C 38 23 33 01 4B 96 + FF 40 08 3F 26 26 D6 7F 27 FB 67 D2 D2 78 07 2D + 3F 8B 8B C6 F7 E2 C8 EA 23 05 7F 55 05 C2 20 2D + 41 92 79 10 26 43 34 69 0E 43 2C 3A F4 66 92 3F + 1B F4 32 B5 AC D4 2E 3A 0D 69 EC 26 97 AA 7F 8C + AE 0F 19 95 91 04 F7 B3 A9 CF 49 C6 E4 8B CC 36 + 82 A3 F2 BD 50 C4 B9 E7 D6 4E B1 1B 1F A7 11 6D +-------------------------------- + +:Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + 0C 6C 9D 71 D0 C9 36 2A 9E B2 03 6A 37 4F A6 65 + FD 85 E5 FD 9D 42 A3 DC AD D8 74 80 E9 BC 3A A6 + 27 +-------------------------------- + +:Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + 74 00 8D 4B 0F E5 64 59 D0 E1 8F 24 1C E4 3F 8C + 5A 10 23 DD EB 20 69 FB 2D 1E 17 5C D7 62 EF A4 + 38 AF 75 C4 A4 01 9B CE 32 A9 29 B9 CA 07 F7 03 + A8 57 40 D9 E6 93 BD D8 E5 DE 5B 25 00 F8 00 35 + 24 +-------------------------------- + +:Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 73 BC D6 13 1E 8E F6 E7 61 75 FE 41 4D 4C E4 19 + D2 C2 14 D6 B7 D7 FF AD 4A 48 21 4E 21 38 11 28 + 4D 20 A8 50 DA A9 7C 6B AC D8 39 8D 50 31 70 94 + 12 15 89 39 9D E7 B9 A8 98 94 B7 38 7B 81 09 13 + 10 08 00 56 00 36 BC B9 CB AF 64 51 83 38 99 FD + 32 7E 2D BF 02 5D 61 A8 D0 1C 6E 50 DF 5C 4D 25 + 17 86 C7 F0 18 9E 25 7A 4C CF B7 CF 7F 9E 30 1A + 98 F1 20 38 41 B7 00 E3 1D 97 31 EB AA C7 89 2E + 3E +-------------------------------- + +:Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED +MAC key = 0 bytes: + (none) /* use InitExt() call */ +Result: + 3F BF 85 49 4D 5C 4A FA 11 8D 66 0C 11 10 25 99 + 01 CB B7 5D E9 E5 D5 7A 48 D0 38 C8 E2 D7 70 A8 + BC FA DB 9D FA 15 D3 E2 9E FB 04 87 2D F4 04 4C + 8A 05 97 4E 50 18 0D D2 95 57 60 5F B5 2B 3F 83 + F2 60 23 73 7C 87 82 2A 20 20 0F 22 4A 1E 94 5E + F5 F4 1E 86 C2 89 B7 AC 5C 81 DD 68 FF 91 5A 2C + 7C 57 11 59 40 8E 35 18 F2 58 4D 80 E3 78 58 A3 + 92 FA 4A B1 74 42 B1 AE A3 95 F1 A8 FF A0 76 03 + 03 7A D3 F2 AA A7 8D 8D C8 D4 16 B2 EA EA BF A5 + 30 08 B5 E8 10 13 CD F8 1B 85 EF C1 B1 D4 9A 7C + 03 C1 69 90 0E 6C 9E 87 AD DE 4D 2A 90 0F 05 CE + 02 18 0A 89 CB A9 32 E0 F3 8B 4D 3B 1A 6C C6 6F + 10 10 6C 71 E3 F4 4F 63 2C A4 01 C1 D6 C3 F6 E8 + A8 67 A4 F7 74 9F 3B 6C 5F 6C 13 18 11 9F 9E FE + C4 56 C3 C4 22 95 00 E0 29 45 04 DD 82 91 24 EA + CA 52 D2 C3 64 F0 A3 53 47 3F 71 86 EC 85 E3 C7 + 54 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 +MAC key = 64 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 +Result: + 22 DF 76 0A F7 DB 7D 18 96 FE C6 C9 87 4F 8E 2A + FA 4B F6 C6 58 56 31 78 66 90 07 4B F2 5F C9 12 + B8 1C 26 B2 53 5E 2C 9F B5 D1 F9 76 4E B0 68 99 + 22 64 77 DD 1E 8A 57 5C 58 22 14 D4 BC 73 ED 86 + D4 08 65 D1 9A D7 BB 99 38 72 D6 39 11 DE F8 5B + AC C9 CC C0 39 4A F4 FC 86 65 89 4B D8 8C 53 38 + 9A 94 DD 9F 64 0D 80 FE 20 F4 70 B8 BB 63 5A AF + DB 20 FB 5F A7 38 FA EA 8F 88 B2 BF 7D BC BF 0E +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 128 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 +Result: + AB 8D 8D AD 35 DC 26 B6 00 B7 F7 AA 00 1C A9 4F + 76 BE 16 7F 3E 9C 57 77 B6 54 93 BA EC EC 5B 73 + F8 DF 22 C2 CD 12 54 EB 0E 38 64 8E 25 24 73 97 + 74 59 7C D4 F5 01 8E 4B 39 A1 CA BB FB FD 1A 25 + 29 F2 AD 4C 27 08 88 F8 17 9C 5B C1 00 2F 2C 2F + C9 66 C2 63 76 AD CB EA EF DB 46 C6 11 CB 35 68 + 91 8B CD 3D 19 56 3E 76 E5 BC 39 BB 97 87 F4 A1 + 3E A2 1E 19 D7 47 7B B9 CB 4B AE 47 23 64 D2 3B +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 +MAC key = 129 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C +Result: + B3 F5 71 FE 68 74 ED AA 68 2A 95 CD 0F FB E0 19 + 59 EC B5 92 C2 39 BF B4 0A 24 6E E6 E4 96 87 25 + BB 3A 93 0F E7 76 95 74 24 CD 65 25 B8 FF 1B BB + FC 7E 09 F5 71 96 1B 10 4F DE 65 0C 07 8E BB 05 + DF 05 22 24 15 D4 AF ED DD 5E 7A 69 E7 D8 25 26 + 98 E0 5D 6B DF C7 1C C7 8D 0D AC 4C 06 56 5C 1F + FB 0B 94 9B E8 F6 03 AA 29 60 54 32 C4 E3 1C 10 + 9D 26 0A FA D2 46 C0 6C 7E 2C A0 D7 7A 51 A2 7A +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'random+MAC' + +Message data: + D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 + 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 + BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 + 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF + F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A + BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 + DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A + 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED + 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 + 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 + 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 + 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 + 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 + 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 + 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF + B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 + FD +MAC key = 257 bytes: + CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 + 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E + 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 + D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 + 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C + AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 + 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 + 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 + 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 + F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB + 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 + BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D + 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 + 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D + 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 + 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 + 44 +Result: + 68 B0 E8 40 0A F4 FB E5 6C BE 6A 84 40 34 83 F1 + 8E AC 53 EE 87 00 14 A3 6F 85 95 AD 8D E4 F6 1F + 0F 51 03 DA 0C AF 32 71 18 10 63 09 A6 0D 46 FB + 86 6B 1A 77 C2 4C B6 19 C0 EB BB CE 5A 8E 1E 74 + 8F 1E 3C EC 6C DD B4 FE D6 E2 95 8B C4 CD 24 19 + 23 28 E2 C8 3D E3 EC 5C BA 3F 48 8A B7 ED C4 AA + 05 BD 51 C6 24 D1 61 71 ED 29 AF DC B6 CA BC 4B + 65 7D FA BA 91 1E 19 30 99 11 06 FC 2B BD 51 6D +-------------------------------- + +:Skein-256: 224-bit hash, msgLen = 1016 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E +Result: + 94 DD EB DE BC B2 F2 B3 52 7C 41 E5 F2 2C 80 02 + A6 F7 53 D3 CD C1 61 31 C9 4B F3 A8 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1008 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 +Result: + 14 03 D6 C9 E9 98 14 A0 BE 30 AE 3E A8 7D 90 C6 + 41 65 0A D0 8C 43 3C 10 83 6E EB 70 65 BD A1 33 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2024 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC +Result: + 4F CE DE 6C 52 B6 66 5A A7 13 22 E2 08 9C 73 9E + B7 76 85 AB D5 11 C3 DA A7 00 7F BD F1 C7 43 04 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4064 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 +Result: + 15 FF 3F A7 08 8B 24 22 A0 5F 08 CF FF 51 75 9B + 1E 6B CD 69 BC 58 3E 7F 90 8C 2F 4B 0A F0 44 8C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 472 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A +Result: + 79 84 1C 27 05 37 71 7D 47 6E 92 42 F4 D2 08 C2 + C8 9E A8 A1 5E 92 DA 75 BF B3 F3 37 09 94 21 1C +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 976 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 +Result: + 26 A6 1E 77 6E C8 B3 DE 92 AF 97 64 29 DA 25 7D + 69 54 0F B4 E7 4A 0F DE 7C 09 DD E0 0E A4 F5 3E +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1992 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 +Result: + 4A 02 4B E7 18 E2 4B 46 89 D1 21 E2 D4 73 93 DC + 48 C8 4A 7B A8 46 C7 4E 5A 8A FB 35 CB D6 87 C1 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 960 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 +Result: + BB 44 F8 B3 29 7A FD 6F 59 BF E8 2F A6 0B 96 AC + 6F B6 E4 81 4B C3 2E 64 11 5B CB 57 5E 14 18 52 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 1976 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 +Result: + 36 DB 18 C4 92 24 98 EF B9 7C A8 46 16 B8 1C 7A + 2D 29 73 BC A4 AE FB B6 03 30 6F 86 46 13 1C F1 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 2992 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 +Result: + F5 81 B0 62 14 B0 26 AC D9 23 07 09 88 02 80 A4 + 9F 1F 5F DE CA 52 4C 27 62 5C 16 D1 11 E0 1E 59 +-------------------------------- + +:Skein-256: 256-bit hash, msgLen = 4008 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 +Result: + 83 4A 5F D1 51 AA D4 7A C2 DC 14 A3 87 E0 D7 1F + 23 4F 09 89 7C 9E A0 8A 8E C2 D1 51 F2 58 3A 1E +-------------------------------- + +:Skein-512: 256-bit hash, msgLen = 2040 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE +Result: + E6 BB 9B 0D E1 1F F6 A3 06 50 13 AB 3D 01 BB 5C + 78 C3 A9 DC F0 2E 81 B9 EA 11 AC 4A BD 78 78 9C +-------------------------------- + +:Skein-512: 384-bit hash, msgLen = 2032 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 +Result: + 38 FE 8D E5 F4 18 53 D1 6E 81 65 55 B8 1C 29 2F + EE 5D 55 6C AD 50 2E CD 8D CE F4 63 44 BE 51 32 + 1C 10 3C 45 F7 C2 38 A8 92 F8 30 C5 2A 82 98 A8 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 2024 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC +Result: + 69 55 9E CF 7B AE 5B C4 27 B5 4D BB 52 1A 0C 29 + 8C 1F F6 63 A0 44 6C 34 8E A3 73 B9 11 56 31 AE + 82 8C 4E 55 78 BC E5 B3 A7 00 32 21 9B ED B3 80 + F3 0B 90 57 9E 12 67 B6 AE 0D 2C 56 7A D8 A6 A3 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4064 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 +Result: + 49 94 F5 D7 4F 56 FE DE 57 01 14 DD 2D 82 5A 73 + B4 12 A1 F6 AA BB 80 0F 3E CD 1C 07 6E 00 FA 79 + C6 0F 24 41 FD 32 C6 62 76 83 34 9D 10 CD 67 88 + 88 0B 59 5B D4 55 68 D5 60 14 61 8B CC 22 6B 68 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8152 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA +Result: + 07 45 F8 6D FD 39 0B D8 80 5B F1 02 CF FD 72 29 + 6E 0E 80 93 F8 C9 97 B5 27 23 2B 99 84 BB B1 50 + 3C DC 4C 1D 9A 6F C1 A2 CB A5 DE 35 1A 8E AA EB + 9E F7 7B D4 3F 63 1E 40 87 5A 4D 0D F9 E8 B3 7F +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 976 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 +Result: + 3A 3D DB C6 04 3E A0 A0 16 D5 35 92 E9 40 7B DD + 4A 7F 29 AD 67 FD 42 A0 EE 26 BA 93 F7 E3 84 9E + AA 0A 65 F3 03 EE B4 7E 5A B6 72 63 05 BF 37 35 + E9 0E 08 C8 EC 88 D9 17 87 FB E6 8A C5 C1 11 37 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1992 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 +Result: + 21 D6 FC 7E BD 06 D4 73 4E 5A 75 D9 32 0D 17 78 + 8A D2 1A C8 68 7A C4 0D B8 67 D7 3A 33 B3 75 A8 + BC 46 C3 23 37 29 E5 31 36 78 07 00 4B 25 49 C8 + 78 DC 7F 07 4C FD 5B 94 22 13 34 59 F1 BE B6 37 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4032 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 +Result: + D1 B1 C5 0F 42 40 FF C5 DA 4D 77 38 DE 6D 04 71 + DD 7E 0A C5 B6 DD 69 66 5D 68 16 FF 68 3A B2 36 + 78 6D 4F 5A 11 12 69 6B B3 88 E2 FD F5 DA BD 00 + 7A 17 27 13 DC D9 4E 9C 3A 41 8B 39 DD CF 03 4C +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 1976 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 +Result: + DF 26 B9 99 9E 00 D0 79 E6 3A E3 4F 99 08 AA 2E + 6A 0B 21 96 C0 AA 2B B4 F5 51 A1 C2 3D 5F E0 9A + 6F 8C 36 34 A9 D0 9D 84 6B 7F 7D D9 57 4A 62 49 + DA 68 1E 9E 8C 43 C8 43 0F A1 4C 5E 17 79 F6 57 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 4016 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 +Result: + 02 5D A3 11 3A 72 A4 30 B6 AB 05 04 7B 42 DD 42 + 82 F7 CD 3E 34 EE 01 88 E6 F0 15 88 79 1A 5F 67 + D9 1A 50 B5 CC 1D 84 0B 00 13 E0 D8 71 F8 6A D2 + 89 D8 F6 11 9A B9 DE AA 72 E9 0D 87 09 F0 CD 3D +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 6056 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 +Result: + 83 07 96 2A 5A 85 01 88 55 30 F2 A8 E0 2F B0 7F + 09 52 BA 27 50 51 D0 53 AD 60 C2 12 0F C1 A9 F5 + BB CE A3 7C F1 6C 45 40 2A C4 0D F6 46 AF 57 F1 + 4C 38 D0 27 F9 B2 E9 CB F9 F1 1E 4C 56 30 01 00 +-------------------------------- + +:Skein-512: 512-bit hash, msgLen = 8096 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 +Result: + 49 6C 64 95 E1 BC 73 46 F6 95 F0 CE 5F 39 8D A2 + 8E 2B BB 74 50 8E 76 97 AA 86 80 20 5A A3 FB 3D + A0 C8 55 7A BA 43 CC 96 0A 1D 82 78 30 BF EA 8A + 43 D9 46 D7 65 97 01 FF 28 3A F5 85 23 C9 7D 21 +-------------------------------- + +:Skein-1024: 384-bit hash, msgLen = 4088 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE +Result: + 4C E9 02 CA C0 1F D0 0D 1E 56 79 CF FD 52 28 06 + 5F CC 7B 2A 12 6A E5 FE 97 C5 52 F1 5F 58 E1 4A + 41 11 65 D9 21 28 E0 4F 53 E8 52 A9 00 33 87 08 +-------------------------------- + +:Skein-1024: 512-bit hash, msgLen = 4080 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 +Result: + 26 6E 45 B7 71 BF 3F 5D 8E 47 44 E4 89 C0 9D F6 + E4 97 D5 09 77 88 2F 4B 01 30 D3 D6 E6 4F 6E 42 + 6F C2 D9 9A 97 E0 90 74 B8 B3 9A B1 20 01 D8 F5 + 16 0A A3 49 B9 42 D8 7E 6A 94 91 4D F8 C9 1B 65 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4072 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC +Result: + 79 0B F0 65 AE A4 1F B7 1E 1E 54 15 C9 DC 61 B1 + 84 6E 25 72 1C BD F3 3D 3E C5 FE 9B 72 A0 7E F2 + 19 CF 6B 50 A3 C9 B0 EB E9 BD C3 64 35 D1 4C A9 + 58 9F 12 93 AB 30 F2 72 9B 8E 0E DD 39 33 AF 87 + A0 26 EF 04 82 B4 6C C8 4C 15 13 17 53 A3 68 72 + AF 07 BA 0D CC F7 5C AD A5 1B 89 07 C1 AD AB C1 + 3F 49 AC FE 1B 2F B6 9A A2 FD F2 45 19 FD 5B 7B + 66 B2 B4 F9 29 EB C5 79 F8 E1 C2 E2 C2 60 77 DA +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8160 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 +Result: + 56 8A 9E 42 AC 13 0D EB DD 95 85 9F BB D3 77 8E + 3E B1 DA 71 9C AF 68 75 D8 B1 DA 3C F9 65 2B DF + C2 BF B8 7D 55 62 BA 20 14 86 4A 35 FE 4F 6D 8D + AE C1 3D 71 BA 9A F9 0C 4B C0 91 59 15 A0 59 50 + BB BA 4D B9 BB F2 CA 2D 56 F0 42 08 07 B2 74 13 + F1 40 D2 EE 7E F3 55 3C 02 6C EF 5C 71 B9 CC C2 + 56 62 A8 35 42 FF 48 18 52 28 62 76 BF 43 C4 2C + 38 85 5F 75 C7 6A 64 4D 3C 1D 2C 93 03 6C 7C 24 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 16344 bits. Tree: leaf=02, node=02, maxLevels=02 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 F4 03 F6 03 F8 03 FA +Result: + 6A 63 EB DF 42 6F 05 AA 34 9C 21 78 4D B2 4C CB + 49 2A 27 BF 30 52 57 04 92 9D 77 FD 76 4B E2 16 + 36 D5 29 DA CB 62 34 07 96 98 DF 23 1C FD AA DD + 84 BA 59 86 7C 9B C1 75 BF 57 95 37 6A 25 E2 EE + FB 47 0C 25 EF A4 02 43 01 A9 14 65 BB 0E DE 85 + 0B 81 29 AE 7C B9 40 FB 26 E6 FE CD 47 7C 82 10 + FA 4D 87 48 FC 67 54 B7 22 8E D5 9D E6 64 BE 13 + B2 A9 F8 5B A3 89 C0 2F D9 A3 F9 91 1B 72 BD 5F +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 2000 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 +Result: + DB 4C B2 F9 54 DD 49 B3 58 58 B8 15 21 91 A3 97 + 9A D1 83 41 66 BF F5 85 AE 84 7F 6A 20 C1 71 7F + 75 B8 26 5C 5A 0C 9D 83 33 53 14 E7 10 1E C5 35 + ED F2 87 AB 1C F6 33 98 10 19 A6 4E E5 22 49 82 + BA 06 88 D7 F7 ED 9D 65 D5 62 93 D0 7A 33 9A 50 + 82 17 F3 4C 53 FC 3D F1 29 53 84 A6 98 D8 ED 25 + 4F 09 FC CE 44 A0 39 53 86 45 7D B0 FD E3 8A F9 + 34 D9 4F 91 A5 15 B5 E7 91 4F B8 89 CF 2A 94 A4 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4040 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 +Result: + F9 FB 4A 9D 8F 8E 50 79 A3 94 CF FF 74 12 82 1D + 94 B9 E5 E2 6A 4E ED E8 F2 40 F4 89 86 17 3A 5B + F0 01 B0 96 A1 48 C4 9F 32 69 17 AD 9F 58 BC EA + 2E 46 E3 8D 87 86 8B 39 48 49 6E 75 B6 54 FB 76 + 4E 06 36 74 01 3B 71 69 B7 6E 91 33 34 93 99 1C + D8 9D 3C 92 89 D9 FC B7 EC BD 12 42 51 FA 38 D9 + 80 61 14 00 7E 6F 65 12 6B 49 B8 D0 75 1C 81 15 + 3F 94 0E 41 B2 18 49 7E 7F FC 96 FC 57 56 96 D5 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8128 bits. Tree: leaf=01, node=02, maxLevels=03 + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 F6 07 +Result: + 39 E1 2A C4 76 65 CE 7F 98 90 2B 9E 7A C5 DD 21 + 57 E9 B1 73 13 9B 91 39 89 09 B7 07 4A 2F 53 2D + A5 69 8D AF 06 8E D5 C0 6D 62 1C FA 94 FA 64 BB + F2 74 BF 8F B7 B8 99 B3 7F 47 AA B0 52 6D C9 32 + 0C 1E AA E9 7B FE 0E 0B 11 17 ED 5E 9B EE 94 FE + 15 DE 3A E2 2C C5 AF 2D 50 C5 0E A3 61 A6 42 0F + 5C 60 05 0F 24 AD 0E 7B E2 EC 4F 24 80 6A 94 46 + 62 74 B9 52 3F 9D AE 79 55 0B C9 19 01 0C 3E 94 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 4024 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 +Result: + E4 78 65 EA 4C AB 29 30 63 52 A8 D8 45 4D 90 67 + A1 14 59 09 78 45 FA C4 5C 5F E6 7F BE 15 46 A5 + 45 E8 A1 F4 21 90 54 24 AE 0C C8 5B 9A F2 CC 8A + 73 5A E4 9C 77 FC FC C4 40 7E 53 CF 52 EA 11 0C + 34 56 5E FB F0 62 11 89 EF F5 13 05 78 36 D7 40 + C8 57 DF A0 71 E6 26 6B 5F 33 3B 71 73 F6 98 ED + E2 A6 B0 55 04 6E E6 62 19 4E 6D FA 65 6F 4D CF + 1F 14 D1 53 D6 AF 99 A8 C3 DD FA 20 63 A9 F5 C5 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 8112 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 +Result: + FA 94 E3 7B 81 8F 4F 78 33 19 AF A3 06 D9 78 88 + 37 D8 E8 72 55 F5 39 05 37 AC 31 96 03 CB 4A DB + 50 CA 42 B2 F1 36 09 E9 D2 EC F7 92 D2 45 B5 DE + E3 A0 6C FE 8B A3 29 3E EC 15 5E F2 35 8C C4 FF + 7C 72 0E 9A B2 DE C0 78 D0 0D 0A EC FD 9F 03 07 + 93 18 B1 AA 4A A7 E1 0E 71 62 D7 2E 06 60 05 26 + 8F 38 8E 2C 7A 2D 5C FE F9 E3 3C CD CF C7 FE 77 + DC A5 C2 A4 6E 42 7E 40 28 40 F2 53 4E EA 48 10 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 12200 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 +Result: + 50 5B 2C D2 1E A6 DA 6E 40 EB CE 77 C6 C1 99 76 + 18 EF CA A4 F5 36 5B DF AD 8F AB 6E 14 C2 FE 5A + 4B E9 15 15 D1 39 A4 6F F1 44 DC 8C 96 DE 61 9D + BE B3 59 31 14 9F F7 28 9C 78 CE B3 CE 24 DF E9 + A9 FC F0 79 C7 E8 28 43 5E F3 17 C4 3E 82 FD 22 + 64 1E 41 12 F1 C5 2D 80 FA DB CF 4C E1 68 02 0A + 72 1E 6B 5C F0 96 AB E4 86 F4 5C F8 22 2F D2 8F + 88 96 F6 45 0E 2A 49 B1 5F FC B6 28 80 1A 7B 31 +-------------------------------- + +:Skein-1024: 1024-bit hash, msgLen = 16288 bits. Tree: leaf=02, node=01, maxLevels=FF + +Message data: + 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 + 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 + 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 + 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 + 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 + 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 + 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 + 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 + 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 + 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 + A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 + B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 + C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 + D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 + E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 + F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 + 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 + 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 + 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 + 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 + 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 + 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 + 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 + 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 + 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 + 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 + A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 + B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 + C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 + D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 + E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 + F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 + 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 + 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 + 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 + 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 + 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 + 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 + 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 + 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 + 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 + 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 + A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 + B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 + C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 + D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 + E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 + F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 + 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 + 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 + 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 + 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 + 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 + 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 + 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 + 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 + 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 + 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 + A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 + B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 + C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 + D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 + E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 + F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 + 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 + 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 + 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 + 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 + 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 + 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 + 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 + 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 + 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 + 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 + A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 + B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 + C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 + D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 + E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 + F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 + 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 + 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 + 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 + 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 + 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 + 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 + 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 + 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 + 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 + 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 + A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 + B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 + C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 + D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 + E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 + F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 + 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 + 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 + 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 + 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 + 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 + 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 + 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 + 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 + 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 + 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 + A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 + B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 + C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 + D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 + E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 + F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 + 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 + 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 + 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 + 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 + 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 + 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 + 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 + 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 + 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 + 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 + A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 + B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 + C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 + D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 + E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 + F0 03 F2 03 +Result: + 28 90 96 9C 8E B1 EB C5 A3 E1 1C 3B B9 40 09 EA + 45 BE 27 70 0C B1 55 2B 19 02 42 32 BE 99 6B AD + 05 77 8E D9 3A D2 7B CB B9 C4 1B EE 73 A1 1D 69 + 73 FA 56 7E 38 ED D6 74 4E BC 7C E6 C6 F9 C0 CC + E9 6A 16 C4 DB E4 0C FD 79 D7 37 E0 9D 85 80 89 + 02 F0 2A 82 DF 66 1E 14 6A 67 8C 8E E6 2C 72 F1 + A1 42 96 80 55 54 8E 77 F3 51 09 51 6B E9 7A 86 + AD 54 95 91 65 3A 51 5D 57 11 21 ED A3 3E AB DD +--------------------------------