From afa4dd2d8fd4c61c9a03aa2da3099536a903e0d1 Mon Sep 17 00:00:00 2001 From: Matt Schultz Date: Sun, 2 Aug 2026 20:10:48 -0500 Subject: [PATCH] Use math/bits.RotateLeft64 for word rotations Replace the manual ((x << r) | (x >> (64-r))) rotate-left idiom in the encrypt paths, and its ((x << (64-r)) | (x >> r)) rotate-right inverse in the decrypt paths, with bits.RotateLeft64(x, r) and bits.RotateLeft64(x, -r) respectively. With constant rotation amounts this compiles to a single ROL/ROR instruction (identical codegen, constant-time), while reading far closer to the spec. Purely mechanical: every changed line is a rotation, and the unchanged known-answer test vectors confirm the behavior is identical. --- threefish1024.go | 257 ++++++++++++++++++++++++----------------------- threefish256.go | 65 ++++++------ threefish512.go | 129 ++++++++++++------------ 3 files changed, 227 insertions(+), 224 deletions(-) diff --git a/threefish1024.go b/threefish1024.go index 5dd4d4b..356c6de 100644 --- a/threefish1024.go +++ b/threefish1024.go @@ -2,6 +2,7 @@ package threefish import ( "crypto/cipher" + "math/bits" ) const ( @@ -117,78 +118,78 @@ func (c *cipher1024) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 24) | (in[1] >> (64 - 24))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 24) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 13) | (in[3] >> (64 - 13))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 13) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 8) | (in[5] >> (64 - 8))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 8) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 47) | (in[7] >> (64 - 47))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 47) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 8) | (in[9] >> (64 - 8))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 8) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 17) | (in[11] >> (64 - 17))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 17) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 22) | (in[13] >> (64 - 22))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 22) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 37) | (in[15] >> (64 - 37))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 37) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 38) | (in[1] >> (64 - 38))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 38) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 19) | (in[3] >> (64 - 19))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 19) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 10) | (in[5] >> (64 - 10))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 10) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 55) | (in[7] >> (64 - 55))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 55) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 49) | (in[9] >> (64 - 49))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 49) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 18) | (in[11] >> (64 - 18))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 18) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 23) | (in[13] >> (64 - 23))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 23) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 52) | (in[15] >> (64 - 52))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 52) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 33) | (in[1] >> (64 - 33))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 33) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 4) | (in[3] >> (64 - 4))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 4) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 51) | (in[5] >> (64 - 51))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 51) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 13) | (in[7] >> (64 - 13))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 13) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 34) | (in[9] >> (64 - 34))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 34) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 41) | (in[11] >> (64 - 41))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 41) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 59) | (in[13] >> (64 - 59))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 59) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 17) | (in[15] >> (64 - 17))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 17) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 5) | (in[1] >> (64 - 5))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 5) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 20) | (in[3] >> (64 - 20))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 20) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 48) | (in[5] >> (64 - 48))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 48) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 41) | (in[7] >> (64 - 41))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 41) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 47) | (in[9] >> (64 - 47))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 47) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 28) | (in[11] >> (64 - 28))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 28) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 16) | (in[13] >> (64 - 16))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 16) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 25) | (in[15] >> (64 - 25))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 25) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] @@ -212,78 +213,78 @@ func (c *cipher1024) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 41) | (in[1] >> (64 - 41))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 41) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 9) | (in[3] >> (64 - 9))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 9) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 37) | (in[5] >> (64 - 37))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 37) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 31) | (in[7] >> (64 - 31))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 31) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 12) | (in[9] >> (64 - 12))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 12) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 47) | (in[11] >> (64 - 47))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 47) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 44) | (in[13] >> (64 - 44))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 44) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 30) | (in[15] >> (64 - 30))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 30) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 16) | (in[1] >> (64 - 16))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 16) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 34) | (in[3] >> (64 - 34))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 34) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 56) | (in[5] >> (64 - 56))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 56) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 51) | (in[7] >> (64 - 51))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 51) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 4) | (in[9] >> (64 - 4))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 4) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 53) | (in[11] >> (64 - 53))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 53) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 42) | (in[13] >> (64 - 42))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 42) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 41) | (in[15] >> (64 - 41))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 41) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 31) | (in[1] >> (64 - 31))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 31) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 44) | (in[3] >> (64 - 44))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 44) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 47) | (in[5] >> (64 - 47))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 47) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 46) | (in[7] >> (64 - 46))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 46) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 19) | (in[9] >> (64 - 19))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 19) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 42) | (in[11] >> (64 - 42))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 42) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 44) | (in[13] >> (64 - 44))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 44) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 25) | (in[15] >> (64 - 25))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 25) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] in[0] += in[1] - in[1] = ((in[1] << 9) | (in[1] >> (64 - 9))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 9) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 48) | (in[3] >> (64 - 48))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 48) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 35) | (in[5] >> (64 - 35))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 35) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 52) | (in[7] >> (64 - 52))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 52) ^ in[6] in[8] += in[9] - in[9] = ((in[9] << 23) | (in[9] >> (64 - 23))) ^ in[8] + in[9] = bits.RotateLeft64(in[9], 23) ^ in[8] in[10] += in[11] - in[11] = ((in[11] << 31) | (in[11] >> (64 - 31))) ^ in[10] + in[11] = bits.RotateLeft64(in[11], 31) ^ in[10] in[12] += in[13] - in[13] = ((in[13] << 37) | (in[13] >> (64 - 37))) ^ in[12] + in[13] = bits.RotateLeft64(in[13], 37) ^ in[12] in[14] += in[15] - in[15] = ((in[15] << 20) | (in[15] >> (64 - 20))) ^ in[14] + in[15] = bits.RotateLeft64(in[15], 20) ^ in[14] in[1], in[3], in[4], in[5], in[6], in[7], in[8], in[9], in[10], in[11], in[12], in[13], in[14], in[15] = in[9], in[13], in[6], in[11], in[4], in[15], in[10], in[7], in[12], in[3], in[14], in[5], in[8], in[1] } @@ -379,78 +380,78 @@ func (c *cipher1024) Decrypt(dst, src []byte) { // Four rounds of permute and unmix ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 20)) | ((ct[15] ^ ct[14]) >> 20) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -20) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 37)) | ((ct[13] ^ ct[12]) >> 37) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -37) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 31)) | ((ct[11] ^ ct[10]) >> 31) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -31) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 23)) | ((ct[9] ^ ct[8]) >> 23) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -23) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 52)) | ((ct[7] ^ ct[6]) >> 52) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -52) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 35)) | ((ct[5] ^ ct[4]) >> 35) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -35) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 48)) | ((ct[3] ^ ct[2]) >> 48) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -48) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 9)) | ((ct[1] ^ ct[0]) >> 9) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -9) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 25)) | ((ct[15] ^ ct[14]) >> 25) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -25) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 44)) | ((ct[13] ^ ct[12]) >> 44) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -44) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 42)) | ((ct[11] ^ ct[10]) >> 42) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -42) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 19)) | ((ct[9] ^ ct[8]) >> 19) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -19) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 46)) | ((ct[7] ^ ct[6]) >> 46) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -46) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 47)) | ((ct[5] ^ ct[4]) >> 47) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -47) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 44)) | ((ct[3] ^ ct[2]) >> 44) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -44) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 31)) | ((ct[1] ^ ct[0]) >> 31) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -31) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 41)) | ((ct[15] ^ ct[14]) >> 41) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -41) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 42)) | ((ct[13] ^ ct[12]) >> 42) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -42) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 53)) | ((ct[11] ^ ct[10]) >> 53) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -53) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 4)) | ((ct[9] ^ ct[8]) >> 4) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -4) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 51)) | ((ct[7] ^ ct[6]) >> 51) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -51) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 56)) | ((ct[5] ^ ct[4]) >> 56) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -56) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 34)) | ((ct[3] ^ ct[2]) >> 34) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -34) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 16)) | ((ct[1] ^ ct[0]) >> 16) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -16) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 30)) | ((ct[15] ^ ct[14]) >> 30) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -30) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 44)) | ((ct[13] ^ ct[12]) >> 44) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -44) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 47)) | ((ct[11] ^ ct[10]) >> 47) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -47) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 12)) | ((ct[9] ^ ct[8]) >> 12) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -12) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 31)) | ((ct[7] ^ ct[6]) >> 31) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -31) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 37)) | ((ct[5] ^ ct[4]) >> 37) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -37) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 9)) | ((ct[3] ^ ct[2]) >> 9) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -9) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 41)) | ((ct[1] ^ ct[0]) >> 41) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -41) ct[0] -= ct[1] // Subtract round key @@ -474,78 +475,78 @@ func (c *cipher1024) Decrypt(dst, src []byte) { // Four rounds of permute and unmix ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 25)) | ((ct[15] ^ ct[14]) >> 25) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -25) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 16)) | ((ct[13] ^ ct[12]) >> 16) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -16) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 28)) | ((ct[11] ^ ct[10]) >> 28) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -28) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 47)) | ((ct[9] ^ ct[8]) >> 47) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -47) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 41)) | ((ct[7] ^ ct[6]) >> 41) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -41) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 48)) | ((ct[5] ^ ct[4]) >> 48) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -48) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 20)) | ((ct[3] ^ ct[2]) >> 20) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -20) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 5)) | ((ct[1] ^ ct[0]) >> 5) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -5) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 17)) | ((ct[15] ^ ct[14]) >> 17) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -17) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 59)) | ((ct[13] ^ ct[12]) >> 59) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -59) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 41)) | ((ct[11] ^ ct[10]) >> 41) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -41) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 34)) | ((ct[9] ^ ct[8]) >> 34) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -34) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 13)) | ((ct[7] ^ ct[6]) >> 13) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -13) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 51)) | ((ct[5] ^ ct[4]) >> 51) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -51) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 4)) | ((ct[3] ^ ct[2]) >> 4) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -4) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 33)) | ((ct[1] ^ ct[0]) >> 33) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -33) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 52)) | ((ct[15] ^ ct[14]) >> 52) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -52) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 23)) | ((ct[13] ^ ct[12]) >> 23) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -23) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 18)) | ((ct[11] ^ ct[10]) >> 18) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -18) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 49)) | ((ct[9] ^ ct[8]) >> 49) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -49) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 55)) | ((ct[7] ^ ct[6]) >> 55) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -55) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 10)) | ((ct[5] ^ ct[4]) >> 10) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -10) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 19)) | ((ct[3] ^ ct[2]) >> 19) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -19) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 38)) | ((ct[1] ^ ct[0]) >> 38) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -38) ct[0] -= ct[1] ct[1], ct[3], ct[4], ct[5], ct[6], ct[7], ct[8], ct[9], ct[10], ct[11], ct[12], ct[13], ct[14], ct[15] = ct[15], ct[11], ct[6], ct[13], ct[4], ct[9], ct[14], ct[1], ct[8], ct[5], ct[10], ct[3], ct[12], ct[7] - ct[15] = ((ct[15] ^ ct[14]) << (64 - 37)) | ((ct[15] ^ ct[14]) >> 37) + ct[15] = bits.RotateLeft64(ct[15]^ct[14], -37) ct[14] -= ct[15] - ct[13] = ((ct[13] ^ ct[12]) << (64 - 22)) | ((ct[13] ^ ct[12]) >> 22) + ct[13] = bits.RotateLeft64(ct[13]^ct[12], -22) ct[12] -= ct[13] - ct[11] = ((ct[11] ^ ct[10]) << (64 - 17)) | ((ct[11] ^ ct[10]) >> 17) + ct[11] = bits.RotateLeft64(ct[11]^ct[10], -17) ct[10] -= ct[11] - ct[9] = ((ct[9] ^ ct[8]) << (64 - 8)) | ((ct[9] ^ ct[8]) >> 8) + ct[9] = bits.RotateLeft64(ct[9]^ct[8], -8) ct[8] -= ct[9] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 47)) | ((ct[7] ^ ct[6]) >> 47) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -47) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 8)) | ((ct[5] ^ ct[4]) >> 8) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -8) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 13)) | ((ct[3] ^ ct[2]) >> 13) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -13) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 24)) | ((ct[1] ^ ct[0]) >> 24) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -24) ct[0] -= ct[1] // Subtract round key diff --git a/threefish256.go b/threefish256.go index bd992fa..8103165 100644 --- a/threefish256.go +++ b/threefish256.go @@ -2,6 +2,7 @@ package threefish import ( "crypto/cipher" + "math/bits" ) const ( @@ -93,27 +94,27 @@ func (c *cipher256) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 14) | (in[1] >> (64 - 14))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 14) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 16) | (in[3] >> (64 - 16))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 16) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 52) | (in[1] >> (64 - 52))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 52) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 57) | (in[3] >> (64 - 57))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 57) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 23) | (in[1] >> (64 - 23))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 23) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 40) | (in[3] >> (64 - 40))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 40) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 5) | (in[1] >> (64 - 5))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 5) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 37) | (in[3] >> (64 - 37))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 37) ^ in[2] in[1], in[3] = in[3], in[1] // Add round key @@ -124,27 +125,27 @@ func (c *cipher256) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 25) | (in[1] >> (64 - 25))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 25) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 33) | (in[3] >> (64 - 33))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 33) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 46) | (in[1] >> (64 - 46))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 46) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 12) | (in[3] >> (64 - 12))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 12) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 58) | (in[1] >> (64 - 58))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 58) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 22) | (in[3] >> (64 - 22))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 22) ^ in[2] in[1], in[3] = in[3], in[1] in[0] += in[1] - in[1] = ((in[1] << 32) | (in[1] >> (64 - 32))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 32) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 32) | (in[3] >> (64 - 32))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 32) ^ in[2] in[1], in[3] = in[3], in[1] } @@ -190,27 +191,27 @@ func (c *cipher256) Decrypt(dst, src []byte) { for d := numRounds256 - 1; d >= 0; d -= 8 { // Four rounds of permute and unmix ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 32)) | ((ct[3] ^ ct[2]) >> 32) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -32) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 32)) | ((ct[1] ^ ct[0]) >> 32) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -32) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 22)) | ((ct[3] ^ ct[2]) >> 22) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -22) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 58)) | ((ct[1] ^ ct[0]) >> 58) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -58) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 12)) | ((ct[3] ^ ct[2]) >> 12) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -12) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 46)) | ((ct[1] ^ ct[0]) >> 46) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -46) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 33)) | ((ct[3] ^ ct[2]) >> 33) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -33) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 25)) | ((ct[1] ^ ct[0]) >> 25) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -25) ct[0] -= ct[1] // Subtract round key @@ -221,27 +222,27 @@ func (c *cipher256) Decrypt(dst, src []byte) { // Four rounds of permute and unmix ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 37)) | ((ct[3] ^ ct[2]) >> 37) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -37) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 5)) | ((ct[1] ^ ct[0]) >> 5) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -5) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 40)) | ((ct[3] ^ ct[2]) >> 40) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -40) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 23)) | ((ct[1] ^ ct[0]) >> 23) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -23) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 57)) | ((ct[3] ^ ct[2]) >> 57) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -57) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 52)) | ((ct[1] ^ ct[0]) >> 52) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -52) ct[0] -= ct[1] ct[1], ct[3] = ct[3], ct[1] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 16)) | ((ct[3] ^ ct[2]) >> 16) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -16) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 14)) | ((ct[1] ^ ct[0]) >> 14) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -14) ct[0] -= ct[1] // Subtract round key diff --git a/threefish512.go b/threefish512.go index 74ce1cc..911da49 100644 --- a/threefish512.go +++ b/threefish512.go @@ -2,6 +2,7 @@ package threefish import ( "crypto/cipher" + "math/bits" ) const ( @@ -101,43 +102,43 @@ func (c *cipher512) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 46) | (in[1] >> (64 - 46))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 46) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 36) | (in[3] >> (64 - 36))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 36) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 19) | (in[5] >> (64 - 19))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 19) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 37) | (in[7] >> (64 - 37))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 37) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 33) | (in[1] >> (64 - 33))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 33) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 27) | (in[3] >> (64 - 27))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 27) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 14) | (in[5] >> (64 - 14))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 14) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 42) | (in[7] >> (64 - 42))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 42) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 17) | (in[1] >> (64 - 17))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 17) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 49) | (in[3] >> (64 - 49))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 49) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 36) | (in[5] >> (64 - 36))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 36) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 39) | (in[7] >> (64 - 39))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 39) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 44) | (in[1] >> (64 - 44))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 44) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 9) | (in[3] >> (64 - 9))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 9) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 54) | (in[5] >> (64 - 54))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 54) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 56) | (in[7] >> (64 - 56))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 56) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] // Add round key @@ -152,43 +153,43 @@ func (c *cipher512) Encrypt(dst, src []byte) { // Four rounds of mix and permute in[0] += in[1] - in[1] = ((in[1] << 39) | (in[1] >> (64 - 39))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 39) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 30) | (in[3] >> (64 - 30))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 30) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 34) | (in[5] >> (64 - 34))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 34) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 24) | (in[7] >> (64 - 24))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 24) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 13) | (in[1] >> (64 - 13))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 13) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 50) | (in[3] >> (64 - 50))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 50) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 10) | (in[5] >> (64 - 10))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 10) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 17) | (in[7] >> (64 - 17))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 17) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 25) | (in[1] >> (64 - 25))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 25) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 29) | (in[3] >> (64 - 29))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 29) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 39) | (in[5] >> (64 - 39))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 39) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 43) | (in[7] >> (64 - 43))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 43) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] in[0] += in[1] - in[1] = ((in[1] << 8) | (in[1] >> (64 - 8))) ^ in[0] + in[1] = bits.RotateLeft64(in[1], 8) ^ in[0] in[2] += in[3] - in[3] = ((in[3] << 35) | (in[3] >> (64 - 35))) ^ in[2] + in[3] = bits.RotateLeft64(in[3], 35) ^ in[2] in[4] += in[5] - in[5] = ((in[5] << 56) | (in[5] >> (64 - 56))) ^ in[4] + in[5] = bits.RotateLeft64(in[5], 56) ^ in[4] in[6] += in[7] - in[7] = ((in[7] << 22) | (in[7] >> (64 - 22))) ^ in[6] + in[7] = bits.RotateLeft64(in[7], 22) ^ in[6] in[0], in[2], in[3], in[4], in[6], in[7] = in[2], in[4], in[7], in[6], in[0], in[3] } @@ -250,43 +251,43 @@ func (c *cipher512) Decrypt(dst, src []byte) { for d := numRounds512 - 1; d >= 0; d -= 8 { // Four rounds of permute and unmix ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 22)) | ((ct[7] ^ ct[6]) >> 22) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -22) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 56)) | ((ct[5] ^ ct[4]) >> 56) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -56) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 35)) | ((ct[3] ^ ct[2]) >> 35) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -35) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 8)) | ((ct[1] ^ ct[0]) >> 8) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -8) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 43)) | ((ct[7] ^ ct[6]) >> 43) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -43) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 39)) | ((ct[5] ^ ct[4]) >> 39) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -39) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 29)) | ((ct[3] ^ ct[2]) >> 29) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -29) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 25)) | ((ct[1] ^ ct[0]) >> 25) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -25) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 17)) | ((ct[7] ^ ct[6]) >> 17) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -17) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 10)) | ((ct[5] ^ ct[4]) >> 10) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -10) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 50)) | ((ct[3] ^ ct[2]) >> 50) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -50) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 13)) | ((ct[1] ^ ct[0]) >> 13) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -13) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 24)) | ((ct[7] ^ ct[6]) >> 24) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -24) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 34)) | ((ct[5] ^ ct[4]) >> 34) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -34) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 30)) | ((ct[3] ^ ct[2]) >> 30) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -30) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 39)) | ((ct[1] ^ ct[0]) >> 39) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -39) ct[0] -= ct[1] // Subtract round key @@ -301,43 +302,43 @@ func (c *cipher512) Decrypt(dst, src []byte) { // Four rounds of permute and unmix ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 56)) | ((ct[7] ^ ct[6]) >> 56) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -56) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 54)) | ((ct[5] ^ ct[4]) >> 54) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -54) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 9)) | ((ct[3] ^ ct[2]) >> 9) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -9) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 44)) | ((ct[1] ^ ct[0]) >> 44) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -44) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 39)) | ((ct[7] ^ ct[6]) >> 39) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -39) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 36)) | ((ct[5] ^ ct[4]) >> 36) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -36) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 49)) | ((ct[3] ^ ct[2]) >> 49) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -49) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 17)) | ((ct[1] ^ ct[0]) >> 17) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -17) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 42)) | ((ct[7] ^ ct[6]) >> 42) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -42) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 14)) | ((ct[5] ^ ct[4]) >> 14) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -14) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 27)) | ((ct[3] ^ ct[2]) >> 27) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -27) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 33)) | ((ct[1] ^ ct[0]) >> 33) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -33) ct[0] -= ct[1] ct[0], ct[2], ct[3], ct[4], ct[6], ct[7] = ct[6], ct[0], ct[7], ct[2], ct[4], ct[3] - ct[7] = ((ct[7] ^ ct[6]) << (64 - 37)) | ((ct[7] ^ ct[6]) >> 37) + ct[7] = bits.RotateLeft64(ct[7]^ct[6], -37) ct[6] -= ct[7] - ct[5] = ((ct[5] ^ ct[4]) << (64 - 19)) | ((ct[5] ^ ct[4]) >> 19) + ct[5] = bits.RotateLeft64(ct[5]^ct[4], -19) ct[4] -= ct[5] - ct[3] = ((ct[3] ^ ct[2]) << (64 - 36)) | ((ct[3] ^ ct[2]) >> 36) + ct[3] = bits.RotateLeft64(ct[3]^ct[2], -36) ct[2] -= ct[3] - ct[1] = ((ct[1] ^ ct[0]) << (64 - 46)) | ((ct[1] ^ ct[0]) >> 46) + ct[1] = bits.RotateLeft64(ct[1]^ct[0], -46) ct[0] -= ct[1] // Subtract round key