/* 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; }
int crypto_hash ( unsigned char *out, const unsigned char *in, unsigned long long inlen ) { Skein_512_Ctxt_t ctx; memcpy(ctx.X,IV,sizeof(ctx.X)); ctx.T[0] = 0; ctx.T[1] = ((uint64) 112) << 56; if (inlen > 64) { size_t n = (inlen-1) / 64; Skein_512_Process_Block(&ctx,in,n,64); inlen -= n * 64; in += n * 64; } memset(ctx.b,0,sizeof(ctx.b)); if (inlen) memcpy(ctx.b,in,inlen); ctx.T[1] |= ((uint64) 128) << 56; Skein_512_Process_Block(&ctx,ctx.b,1,inlen); memset(ctx.b,0,sizeof(ctx.b)); ctx.T[0] = 0; ctx.T[1] = ((uint64) 255) << 56; Skein_512_Process_Block(&ctx,ctx.b,1,sizeof(uint64)); Skein_Put64_LSB_First(out,ctx.X,crypto_hash_BYTES); return 0; }
int crypto_hash(unsigned char *out, const unsigned char *in, unsigned long long inlen) { // Init state ctx; memcpy(ctx.X, SKEIN_512_IV_256, sizeof(ctx.X)); ctx.T[0] = 0; ctx.T[1] = 0x7000000000000000ull; // Update if (inlen > 64) { size_t n = (inlen - 1) / 64; Skein_512_Process_Block(&ctx, in, n, 64); inlen -= n * 64; in += n * 64; } // Final u8 buf[64] = {0}; // zero pad memcpy(buf, in, inlen); ctx.T[1] |= 0x8000000000000000ull; // set final flag Skein_512_Process_Block(&ctx, buf, 1, inlen); // generate hash memset(buf, 0, 64); ctx.T[0] = 0; ctx.T[1] = 0xFF00000000000000ull; Skein_512_Process_Block(&ctx, buf, 1, 8); memcpy(out, ctx.X, 32); return 0; }
/* process the input bytes */ int Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt) { size_t n; /* catch uninitialized context */ Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) { /* finish up any buffered message data */ if (ctx->h.bCnt) { /* # bytes free in buffer b[] */ n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; if (n) { /* check on our logic here */ Skein_assert(n < msgByteCnt); bcopy(msg, &ctx->b[ctx->h.bCnt], 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) { /* number of full blocks to process */ n = (msgByteCnt - 1) / SKEIN_512_BLOCK_BYTES; 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); bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt); ctx->h.bCnt += msgByteCnt; } return (SKEIN_SUCCESS); }
/* init the context for a straight hashing operation */ int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) { union { uint8_t b[SKEIN_512_STATE_BYTES]; uint64_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: bcopy(SKEIN_512_IV_512, ctx->X, sizeof (ctx->X)); break; case 384: bcopy(SKEIN_512_IV_384, ctx->X, sizeof (ctx->X)); break; case 256: bcopy(SKEIN_512_IV_256, ctx->X, sizeof (ctx->X)); break; case 224: bcopy(SKEIN_512_IV_224, ctx->X, 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) */ /* set tweaks: T0=0; T1=CFG | FINAL */ Skein_Start_New_Type(ctx, CFG_FINAL); /* set the schema, version */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* hash result length in bits */ cfg.w[1] = Skein_Swap64(hashBitLen); cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* zero pad config block */ bzero(&cfg.w[3], sizeof (cfg) - 3 * sizeof (cfg.w[0])); /* compute the initial chaining values from config block */ /* zero the chaining variables */ bzero(ctx->X, sizeof (ctx->X)); 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); }
/* [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; }
int skeinmid(unsigned char *out, const unsigned char *in) { Skein_512_Ctxt_t ctx; memcpy(ctx.X,IV,sizeof(ctx.X)); ctx.T[0] = 0; ctx.T[1] = ((uint64) 112) << 56; Skein_512_Process_Block(&ctx,in,1,64); memcpy(out, ctx.X, 64); return 0; }
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; }
int crypto_hash ( unsigned char *out, const unsigned char *in, unsigned long long inlen ) { Skein_512_Ctxt_t ctx; memcpy(ctx.X,IV,sizeof(ctx.X)); ctx.T[0] = _mm_set_pi32(0,0); ctx.T[1] = _mm_set_pi32(((uint32) 112) << 24,0); if (inlen > 64) { size_t n = (inlen-1) / 64; Skein_512_Process_Block(&ctx,in,n,64); inlen -= n * 64; in += n * 64; } memset(ctx.b,0,sizeof(ctx.b)); if (inlen) memcpy(ctx.b,in,inlen); ctx.T[1] = _mm_or_si64(ctx.T[1],_mm_set_pi32(((uint32) 128) << 24,0)); Skein_512_Process_Block(&ctx,ctx.b,1,inlen); memset(ctx.b,0,sizeof(ctx.b)); ctx.T[0] = _mm_set_pi32(0,0); ctx.T[1] = _mm_set_pi32(((uint32) 255) << 24,0); Skein_512_Process_Block(&ctx,ctx.b,1,sizeof(uint64)); 0[(__m64 *) out] = ctx.X[0]; 1[(__m64 *) out] = ctx.X[1]; 2[(__m64 *) out] = ctx.X[2]; 3[(__m64 *) out] = ctx.X[3]; return 0; }
/* just do the OUTPUT stage */ int Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal) { size_t i, n, byteCnt; uint64_t X[SKEIN_512_STATE_WORDS]; /* catch uninitialized context */ Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES, SKEIN_FAIL); /* now output the result */ /* total number of output bytes */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* run Threefish in "counter mode" to generate output */ /* zero out b[], so it can hold the counter */ bzero(ctx->b, sizeof (ctx->b)); /* keep a local copy of counter mode "key" */ bcopy(ctx->X, X, sizeof (X)); for (i = 0; i * SKEIN_512_BLOCK_BYTES < byteCnt; i++) { /* build the counter block */ uint64_t tmp = Skein_Swap64((uint64_t)i); bcopy(&tmp, ctx->b, sizeof (tmp)); Skein_Start_New_Type(ctx, OUT_FINAL); /* run "counter mode" */ Skein_512_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t)); /* number of output bytes left to go */ n = byteCnt - i * SKEIN_512_BLOCK_BYTES; 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); /* restore the counter mode key for next time */ bcopy(X, ctx->X, sizeof (X)); } return (SKEIN_SUCCESS); }