Remove bcopy(), bzero(), bcmp()

[mirror_zfs.git] / module / icp / algs / skein / skein.c

diff --git a/module/icp/algs/skein/skein.c b/module/icp/algs/skein/skein.c
index 83fe8426030728daa1d81de9ace866aedf477502..41ed2dd44e9ef1fd06e3231f6fdff02512a7a103 100644 (file)
--- a/module/icp/algs/skein/skein.c
+++ b/module/icp/algs/skein/skein.c
@@ -26,16 +26,16 @@ Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen)
        switch (hashBitLen) {   /* use pre-computed values, where available */
 #ifndef        SKEIN_NO_PRECOMP
        case 256:
-               bcopy(SKEIN_256_IV_256, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_256_IV_256, sizeof (ctx->X));
                break;
        case 224:
-               bcopy(SKEIN_256_IV_224, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_256_IV_224, sizeof (ctx->X));
                break;
        case 160:
-               bcopy(SKEIN_256_IV_160, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_256_IV_160, sizeof (ctx->X));
                break;
        case 128:
-               bcopy(SKEIN_256_IV_128, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_256_IV_128, sizeof (ctx->X));
                break;
 #endif
        default:
@@ -53,11 +53,11 @@ Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen)
                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]));
+               memset(&cfg.w[3], 0, 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));
+               memset(ctx->X, 0, sizeof (ctx->X));
                Skein_256_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
                break;
        }
@@ -91,7 +91,7 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        /* compute the initial chaining values ctx->X[], based on key */
        if (keyBytes == 0) {    /* is there a key? */
                /* no key: use all zeroes as key for config block */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
        } else {                /* here to pre-process a key */
 
                Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X));
@@ -101,13 +101,13 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
                /* set tweaks: T0 = 0; T1 = KEY type */
                Skein_Start_New_Type(ctx, KEY);
                /* zero the initial chaining variables */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
                /* hash the key */
                (void) Skein_256_Update(ctx, key, keyBytes);
                /* put result into cfg.b[] */
                (void) Skein_256_Final_Pad(ctx, cfg.b);
                /* copy over into ctx->X[] */
-               bcopy(cfg.b, ctx->X, sizeof (cfg.b));
+               memcpy(ctx->X, cfg.b, sizeof (cfg.b));
 #if    SKEIN_NEED_SWAP
                {
                        uint_t i;
@@ -124,7 +124,7 @@ Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        ctx->h.hashBitLen = hashBitLen; /* output hash bit count */
        Skein_Start_New_Type(ctx, CFG_FINAL);
 
-       bzero(&cfg.w, sizeof (cfg.w));  /* pre-pad cfg.w[] with zeroes */
+       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 */
        /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */
@@ -161,7 +161,7 @@ Skein_256_Update(Skein_256_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
                        if (n) {
                                /* check on our logic here */
                                Skein_assert(n < msgByteCnt);
-                               bcopy(msg, &ctx->b[ctx->h.bCnt], n);
+                               memcpy(&ctx->b[ctx->h.bCnt], msg, n);
                                msgByteCnt -= n;
                                msg += n;
                                ctx->h.bCnt += n;
@@ -189,7 +189,7 @@ Skein_256_Update(Skein_256_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
        /* copy any remaining source message data bytes into b[] */
        if (msgByteCnt) {
                Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES);
-               bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt);
+               memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt);
                ctx->h.bCnt += msgByteCnt;
        }
 
@@ -209,7 +209,7 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;     /* tag as the final block */
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN_256_BLOCK_BYTES - ctx->h.bCnt);
 
        /* process the final block */
@@ -221,13 +221,12 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->X, sizeof (X));
        for (i = 0; i * SKEIN_256_BLOCK_BYTES < byteCnt; i++) {
                /* build the counter block */
-               uint64_t tmp = Skein_Swap64((uint64_t)i);
-               bcopy(&tmp, ctx->b, sizeof (tmp));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein_256_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -240,7 +239,7 @@ Skein_256_Final(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
                Skein_Show_Final(256, &ctx->h, n,
                    hashVal + i * SKEIN_256_BLOCK_BYTES);
                /* restore the counter mode key for next time */
-               bcopy(X, ctx->X, sizeof (X));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }
@@ -262,16 +261,16 @@ Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen)
        switch (hashBitLen) {   /* use pre-computed values, where available */
 #ifndef        SKEIN_NO_PRECOMP
        case 512:
-               bcopy(SKEIN_512_IV_512, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_512_IV_512, sizeof (ctx->X));
                break;
        case 384:
-               bcopy(SKEIN_512_IV_384, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_512_IV_384, sizeof (ctx->X));
                break;
        case 256:
-               bcopy(SKEIN_512_IV_256, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_512_IV_256, sizeof (ctx->X));
                break;
        case 224:
-               bcopy(SKEIN_512_IV_224, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN_512_IV_224, sizeof (ctx->X));
                break;
 #endif
        default:
@@ -289,11 +288,11 @@ Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen)
                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]));
+               memset(&cfg.w[3], 0, 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));
+               memset(ctx->X, 0, sizeof (ctx->X));
                Skein_512_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
                break;
        }
@@ -328,7 +327,7 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        /* compute the initial chaining values ctx->X[], based on key */
        if (keyBytes == 0) {    /* is there a key? */
                /* no key: use all zeroes as key for config block */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
        } else {                /* here to pre-process a key */
 
                Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X));
@@ -338,12 +337,12 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
                /* set tweaks: T0 = 0; T1 = KEY type */
                Skein_Start_New_Type(ctx, KEY);
                /* zero the initial chaining variables */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
                (void) Skein_512_Update(ctx, key, keyBytes); /* hash the key */
                /* put result into cfg.b[] */
                (void) Skein_512_Final_Pad(ctx, cfg.b);
                /* copy over into ctx->X[] */
-               bcopy(cfg.b, ctx->X, sizeof (cfg.b));
+               memcpy(ctx->X, cfg.b, sizeof (cfg.b));
 #if    SKEIN_NEED_SWAP
                {
                        uint_t i;
@@ -360,7 +359,7 @@ Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        ctx->h.hashBitLen = hashBitLen; /* output hash bit count */
        Skein_Start_New_Type(ctx, CFG_FINAL);
 
-       bzero(&cfg.w, sizeof (cfg.w));  /* pre-pad cfg.w[] with zeroes */
+       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 */
        /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */
@@ -397,7 +396,7 @@ Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
                        if (n) {
                                /* check on our logic here */
                                Skein_assert(n < msgByteCnt);
-                               bcopy(msg, &ctx->b[ctx->h.bCnt], n);
+                               memcpy(&ctx->b[ctx->h.bCnt], msg, n);
                                msgByteCnt -= n;
                                msg += n;
                                ctx->h.bCnt += n;
@@ -425,7 +424,7 @@ Skein_512_Update(Skein_512_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
        /* 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);
+               memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt);
                ctx->h.bCnt += msgByteCnt;
        }
 
@@ -445,7 +444,7 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;     /* tag as the final block */
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN_512_BLOCK_BYTES - ctx->h.bCnt);
 
        /* process the final block */
@@ -457,13 +456,12 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->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));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein_512_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -476,7 +474,7 @@ Skein_512_Final(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
                Skein_Show_Final(512, &ctx->h, n,
                    hashVal + i * SKEIN_512_BLOCK_BYTES);
                /* restore the counter mode key for next time */
-               bcopy(X, ctx->X, sizeof (X));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }
@@ -498,13 +496,13 @@ Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen)
        switch (hashBitLen) {   /* use pre-computed values, where available */
 #ifndef        SKEIN_NO_PRECOMP
        case 512:
-               bcopy(SKEIN1024_IV_512, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN1024_IV_512, sizeof (ctx->X));
                break;
        case 384:
-               bcopy(SKEIN1024_IV_384, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN1024_IV_384, sizeof (ctx->X));
                break;
        case 1024:
-               bcopy(SKEIN1024_IV_1024, ctx->X, sizeof (ctx->X));
+               memcpy(ctx->X, SKEIN1024_IV_1024, sizeof (ctx->X));
                break;
 #endif
        default:
@@ -522,11 +520,11 @@ Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen)
                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]));
+               memset(&cfg.w[3], 0, 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));
+               memset(ctx->X, 0, sizeof (ctx->X));
                Skein1024_Process_Block(ctx, cfg.b, 1, SKEIN_CFG_STR_LEN);
                break;
        }
@@ -561,7 +559,7 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        /* compute the initial chaining values ctx->X[], based on key */
        if (keyBytes == 0) {    /* is there a key? */
                /* no key: use all zeroes as key for config block */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
        } else {                /* here to pre-process a key */
                Skein_assert(sizeof (cfg.b) >= sizeof (ctx->X));
                /* do a mini-Init right here */
@@ -570,12 +568,12 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
                /* set tweaks: T0 = 0; T1 = KEY type */
                Skein_Start_New_Type(ctx, KEY);
                /* zero the initial chaining variables */
-               bzero(ctx->X, sizeof (ctx->X));
+               memset(ctx->X, 0, sizeof (ctx->X));
                (void) Skein1024_Update(ctx, key, keyBytes); /* hash the key */
                /* put result into cfg.b[] */
                (void) Skein1024_Final_Pad(ctx, cfg.b);
                /* copy over into ctx->X[] */
-               bcopy(cfg.b, ctx->X, sizeof (cfg.b));
+               memcpy(ctx->X, cfg.b, sizeof (cfg.b));
 #if    SKEIN_NEED_SWAP
                {
                        uint_t i;
@@ -592,7 +590,7 @@ Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, uint64_t treeInfo,
        ctx->h.hashBitLen = hashBitLen; /* output hash bit count */
        Skein_Start_New_Type(ctx, CFG_FINAL);
 
-       bzero(&cfg.w, sizeof (cfg.w));  /* pre-pad cfg.w[] with zeroes */
+       memset(&cfg.w, 0, sizeof (cfg.w)); /* pre-pad cfg.w[] with zeroes */
        cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER);
        /* hash result length in bits */
        cfg.w[1] = Skein_Swap64(hashBitLen);
@@ -630,7 +628,7 @@ Skein1024_Update(Skein1024_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
                        if (n) {
                                /* check on our logic here */
                                Skein_assert(n < msgByteCnt);
-                               bcopy(msg, &ctx->b[ctx->h.bCnt], n);
+                               memcpy(&ctx->b[ctx->h.bCnt], msg, n);
                                msgByteCnt -= n;
                                msg += n;
                                ctx->h.bCnt += n;
@@ -658,7 +656,7 @@ Skein1024_Update(Skein1024_Ctxt_t *ctx, const uint8_t *msg, size_t msgByteCnt)
        /* copy any remaining source message data bytes into b[] */
        if (msgByteCnt) {
                Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES);
-               bcopy(msg, &ctx->b[ctx->h.bCnt], msgByteCnt);
+               memcpy(&ctx->b[ctx->h.bCnt], msg, msgByteCnt);
                ctx->h.bCnt += msgByteCnt;
        }
 
@@ -678,7 +676,7 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;     /* tag as the final block */
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN1024_BLOCK_BYTES - ctx->h.bCnt);
 
        /* process the final block */
@@ -690,13 +688,12 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->X, sizeof (X));
        for (i = 0; i * SKEIN1024_BLOCK_BYTES < byteCnt; i++) {
                /* build the counter block */
-               uint64_t tmp = Skein_Swap64((uint64_t)i);
-               bcopy(&tmp, ctx->b, sizeof (tmp));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein1024_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -709,7 +706,7 @@ Skein1024_Final(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
                Skein_Show_Final(1024, &ctx->h, n,
                    hashVal + i * SKEIN1024_BLOCK_BYTES);
                /* restore the counter mode key for next time */
-               bcopy(X, ctx->X, sizeof (X));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }
@@ -727,7 +724,7 @@ Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;     /* tag as the final block */
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN_256_BLOCK_BYTES - ctx->h.bCnt);
        /* process the final block */
        Skein_256_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt);
@@ -748,7 +745,7 @@ Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;     /* tag as the final block */
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN_512_BLOCK_BYTES - ctx->h.bCnt);
        /* process the final block */
        Skein_512_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt);
@@ -770,7 +767,7 @@ Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
        ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL;
        /* zero pad b[] if necessary */
        if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES)
-               bzero(&ctx->b[ctx->h.bCnt],
+               memset(&ctx->b[ctx->h.bCnt], 0,
                    SKEIN1024_BLOCK_BYTES - ctx->h.bCnt);
        /* process the final block */
        Skein1024_Process_Block(ctx, ctx->b, 1, ctx->h.bCnt);
@@ -798,13 +795,12 @@ Skein_256_Output(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->X, sizeof (X));
        for (i = 0; i * SKEIN_256_BLOCK_BYTES < byteCnt; i++) {
                /* build the counter block */
-               uint64_t tmp = Skein_Swap64((uint64_t)i);
-               bcopy(&tmp, ctx->b, sizeof (tmp));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein_256_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -817,7 +813,7 @@ Skein_256_Output(Skein_256_Ctxt_t *ctx, uint8_t *hashVal)
                Skein_Show_Final(256, &ctx->h, n,
                    hashVal + i * SKEIN_256_BLOCK_BYTES);
                /* restore the counter mode key for next time */
-               bcopy(X, ctx->X, sizeof (X));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }
@@ -838,13 +834,12 @@ Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->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));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein_512_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -857,7 +852,7 @@ Skein_512_Output(Skein_512_Ctxt_t *ctx, uint8_t *hashVal)
                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));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }
@@ -878,13 +873,12 @@ Skein1024_Output(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
 
        /* run Threefish in "counter mode" to generate output */
        /* zero out b[], so it can hold the counter */
-       bzero(ctx->b, sizeof (ctx->b));
+       memset(ctx->b, 0, sizeof (ctx->b));
        /* keep a local copy of counter mode "key" */
-       bcopy(ctx->X, X, sizeof (X));
+       memcpy(X, ctx->X, sizeof (X));
        for (i = 0; i * SKEIN1024_BLOCK_BYTES < byteCnt; i++) {
                /* build the counter block */
-               uint64_t tmp = Skein_Swap64((uint64_t)i);
-               bcopy(&tmp, ctx->b, sizeof (tmp));
+               *(uint64_t *)ctx->b = Skein_Swap64((uint64_t)i);
                Skein_Start_New_Type(ctx, OUT_FINAL);
                /* run "counter mode" */
                Skein1024_Process_Block(ctx, ctx->b, 1, sizeof (uint64_t));
@@ -897,7 +891,7 @@ Skein1024_Output(Skein1024_Ctxt_t *ctx, uint8_t *hashVal)
                Skein_Show_Final(256, &ctx->h, n,
                    hashVal + i * SKEIN1024_BLOCK_BYTES);
                /* restore the counter mode key for next time */
-               bcopy(X, ctx->X, sizeof (X));
+               memcpy(ctx->X, X, sizeof (X));
        }
        return (SKEIN_SUCCESS);
 }