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

bcopy() has a confusing argument order and is actually a move, not a copy; they're all deprecated since POSIX.1-2001 and removed in -2008, and we shim them out to mem*() on Linux anyway Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov> Signed-off-by: Ahelenia Ziemiańska <nabijaczleweli@nabijaczleweli.xyz> Closes #12996
2026-05-26 20:22:14 +03:00 · 2022-02-25 14:26:54 +01:00
parent 1d77d62f5a
commit 861166b027
129 changed files with 990 additions and 1051 deletions
@@ -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);
 }
@@ -50,9 +50,9 @@
 #else
 /* here for x86 and x86-64 CPUs (and other detected little-endian CPUs) */
 #define	SKEIN_NEED_SWAP   (0)
-#define	Skein_Put64_LSB_First(dst08, src64, bCnt) bcopy(src64, dst08, bCnt)
+#define	Skein_Put64_LSB_First(dst08, src64, bCnt) memcpy(dst08, src64, bCnt)
 #define	Skein_Get64_LSB_First(dst64, src08, wCnt) \
-	bcopy(src08, dst64, 8 * (wCnt))
+	memcpy(dst64, src08, 8 * (wCnt))
 #endif

 #endif				/* ifndef SKEIN_NEED_SWAP */