Skip to content

Commit 5946157

Browse files
AlexanderYastrebovAlexanderYastrebov
committed
all: use math/bits.RotateLeft
Updates golang/go#31456
1 parent eccd636 commit 5946157

File tree

8 files changed

+254
-251
lines changed

8 files changed

+254
-251
lines changed

‎cast5/cast5.go

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,10 @@
1313
// golang.org/x/crypto/chacha20poly1305).
1414
package cast5 // import "golang.org/x/crypto/cast5"
1515

16-
import "errors"
16+
import (
17+
"errors"
18+
"math/bits"
19+
)
1720

1821
const BlockSize = 8
1922
const KeySize = 16
@@ -241,19 +244,19 @@ func (c *Cipher) keySchedule(in []byte) {
241244
// These are the three 'f' functions. See RFC 2144, section 2.2.
242245
func f1(d, m uint32, r uint8) uint32 {
243246
t := m + d
244-
I := (t << r) | (t >> (32 - r))
247+
I := bits.RotateLeft32(t, int(r))
245248
return ((sBox[0][I>>24] ^ sBox[1][(I>>16)&0xff]) - sBox[2][(I>>8)&0xff]) + sBox[3][I&0xff]
246249
}
247250

248251
func f2(d, m uint32, r uint8) uint32 {
249252
t := m ^ d
250-
I := (t << r) | (t >> (32 - r))
253+
I := bits.RotateLeft32(t, int(r))
251254
return ((sBox[0][I>>24] - sBox[1][(I>>16)&0xff]) + sBox[2][(I>>8)&0xff]) ^ sBox[3][I&0xff]
252255
}
253256

254257
func f3(d, m uint32, r uint8) uint32 {
255258
t := m - d
256-
I := (t << r) | (t >> (32 - r))
259+
I := bits.RotateLeft32(t, int(r))
257260
return ((sBox[0][I>>24] + sBox[1][(I>>16)&0xff]) ^ sBox[2][(I>>8)&0xff]) - sBox[3][I&0xff]
258261
}
259262

‎md4/md4block.go

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,11 @@
88

99
package md4
1010

11-
var shift1 = []uint{3, 7, 11, 19}
12-
var shift2 = []uint{3, 5, 9, 13}
13-
var shift3 = []uint{3, 9, 11, 15}
11+
import "math/bits"
12+
13+
var shift1 = []int{3, 7, 11, 19}
14+
var shift2 = []int{3, 5, 9, 13}
15+
var shift3 = []int{3, 9, 11, 15}
1416

1517
var xIndex2 = []uint{0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15}
1618
var xIndex3 = []uint{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15}
@@ -48,7 +50,7 @@ func _Block(dig *digest, p []byte) int {
4850
s := shift1[i%4]
4951
f := ((c ^ d) & b) ^ d
5052
a += f + X[x]
51-
a = a<<s | a>>(32-s)
53+
a = bits.RotateLeft32(a, s)
5254
a, b, c, d = d, a, b, c
5355
}
5456

@@ -58,7 +60,7 @@ func _Block(dig *digest, p []byte) int {
5860
s := shift2[i%4]
5961
g := (b & c) | (b & d) | (c & d)
6062
a += g + X[x] + 0x5a827999
61-
a = a<<s | a>>(32-s)
63+
a = bits.RotateLeft32(a, s)
6264
a, b, c, d = d, a, b, c
6365
}
6466

@@ -68,7 +70,7 @@ func _Block(dig *digest, p []byte) int {
6870
s := shift3[i%4]
6971
h := b ^ c ^ d
7072
a += h + X[x] + 0x6ed9eba1
71-
a = a<<s | a>>(32-s)
73+
a = bits.RotateLeft32(a, s)
7274
a, b, c, d = d, a, b, c
7375
}
7476

‎pkcs12/internal/rc2/rc2.go

Lines changed: 25 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ package rc2
1414
import (
1515
"crypto/cipher"
1616
"encoding/binary"
17+
"math/bits"
1718
)
1819

1920
// The rc2 block size in bytes
@@ -80,10 +81,6 @@ func expandKey(key []byte, t1 int) [64]uint16 {
8081
return k
8182
}
8283

83-
func rotl16(x uint16, b uint) uint16 {
84-
return (x >> (16 - b)) | (x << b)
85-
}
86-
8784
func (c *rc2Cipher) Encrypt(dst, src []byte) {
8885

8986
r0 := binary.LittleEndian.Uint16(src[0:])
@@ -96,22 +93,22 @@ func (c *rc2Cipher) Encrypt(dst, src []byte) {
9693
for j <= 16 {
9794
// mix r0
9895
r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
99-
r0 = rotl16(r0, 1)
96+
r0 = bits.RotateLeft16(r0, 1)
10097
j++
10198

10299
// mix r1
103100
r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
104-
r1 = rotl16(r1, 2)
101+
r1 = bits.RotateLeft16(r1, 2)
105102
j++
106103

107104
// mix r2
108105
r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
109-
r2 = rotl16(r2, 3)
106+
r2 = bits.RotateLeft16(r2, 3)
110107
j++
111108

112109
// mix r3
113110
r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
114-
r3 = rotl16(r3, 5)
111+
r3 = bits.RotateLeft16(r3, 5)
115112
j++
116113

117114
}
@@ -124,22 +121,22 @@ func (c *rc2Cipher) Encrypt(dst, src []byte) {
124121
for j <= 40 {
125122
// mix r0
126123
r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
127-
r0 = rotl16(r0, 1)
124+
r0 = bits.RotateLeft16(r0, 1)
128125
j++
129126

130127
// mix r1
131128
r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
132-
r1 = rotl16(r1, 2)
129+
r1 = bits.RotateLeft16(r1, 2)
133130
j++
134131

135132
// mix r2
136133
r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
137-
r2 = rotl16(r2, 3)
134+
r2 = bits.RotateLeft16(r2, 3)
138135
j++
139136

140137
// mix r3
141138
r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
142-
r3 = rotl16(r3, 5)
139+
r3 = bits.RotateLeft16(r3, 5)
143140
j++
144141

145142
}
@@ -152,22 +149,22 @@ func (c *rc2Cipher) Encrypt(dst, src []byte) {
152149
for j <= 60 {
153150
// mix r0
154151
r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
155-
r0 = rotl16(r0, 1)
152+
r0 = bits.RotateLeft16(r0, 1)
156153
j++
157154

158155
// mix r1
159156
r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
160-
r1 = rotl16(r1, 2)
157+
r1 = bits.RotateLeft16(r1, 2)
161158
j++
162159

163160
// mix r2
164161
r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
165-
r2 = rotl16(r2, 3)
162+
r2 = bits.RotateLeft16(r2, 3)
166163
j++
167164

168165
// mix r3
169166
r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
170-
r3 = rotl16(r3, 5)
167+
r3 = bits.RotateLeft16(r3, 5)
171168
j++
172169
}
173170

@@ -188,22 +185,22 @@ func (c *rc2Cipher) Decrypt(dst, src []byte) {
188185

189186
for j >= 44 {
190187
// unmix r3
191-
r3 = rotl16(r3, 16-5)
188+
r3 = bits.RotateLeft16(r3, 16-5)
192189
r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
193190
j--
194191

195192
// unmix r2
196-
r2 = rotl16(r2, 16-3)
193+
r2 = bits.RotateLeft16(r2, 16-3)
197194
r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
198195
j--
199196

200197
// unmix r1
201-
r1 = rotl16(r1, 16-2)
198+
r1 = bits.RotateLeft16(r1, 16-2)
202199
r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
203200
j--
204201

205202
// unmix r0
206-
r0 = rotl16(r0, 16-1)
203+
r0 = bits.RotateLeft16(r0, 16-1)
207204
r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
208205
j--
209206
}
@@ -215,22 +212,22 @@ func (c *rc2Cipher) Decrypt(dst, src []byte) {
215212

216213
for j >= 20 {
217214
// unmix r3
218-
r3 = rotl16(r3, 16-5)
215+
r3 = bits.RotateLeft16(r3, 16-5)
219216
r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
220217
j--
221218

222219
// unmix r2
223-
r2 = rotl16(r2, 16-3)
220+
r2 = bits.RotateLeft16(r2, 16-3)
224221
r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
225222
j--
226223

227224
// unmix r1
228-
r1 = rotl16(r1, 16-2)
225+
r1 = bits.RotateLeft16(r1, 16-2)
229226
r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
230227
j--
231228

232229
// unmix r0
233-
r0 = rotl16(r0, 16-1)
230+
r0 = bits.RotateLeft16(r0, 16-1)
234231
r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
235232
j--
236233

@@ -243,22 +240,22 @@ func (c *rc2Cipher) Decrypt(dst, src []byte) {
243240

244241
for j >= 0 {
245242
// unmix r3
246-
r3 = rotl16(r3, 16-5)
243+
r3 = bits.RotateLeft16(r3, 16-5)
247244
r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
248245
j--
249246

250247
// unmix r2
251-
r2 = rotl16(r2, 16-3)
248+
r2 = bits.RotateLeft16(r2, 16-3)
252249
r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
253250
j--
254251

255252
// unmix r1
256-
r1 = rotl16(r1, 16-2)
253+
r1 = bits.RotateLeft16(r1, 16-2)
257254
r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
258255
j--
259256

260257
// unmix r0
261-
r0 = rotl16(r0, 16-1)
258+
r0 = bits.RotateLeft16(r0, 16-1)
262259
r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
263260
j--
264261

‎salsa20/salsa/hsalsa20.go

Lines changed: 34 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,8 @@
55
// Package salsa provides low-level access to functions in the Salsa family.
66
package salsa // import "golang.org/x/crypto/salsa20/salsa"
77

8+
import "math/bits"
9+
810
// Sigma is the Salsa20 constant for 256-bit keys.
911
var Sigma = [16]byte{'e', 'x', 'p', 'a', 'n', 'd', ' ', '3', '2', '-', 'b', 'y', 't', 'e', ' ', 'k'}
1012

@@ -31,76 +33,76 @@ func HSalsa20(out *[32]byte, in *[16]byte, k *[32]byte, c *[16]byte) {
3133

3234
for i := 0; i < 20; i += 2 {
3335
u := x0 + x12
34-
x4 ^= u<<7 | u>>(32-7)
36+
x4 ^= bits.RotateLeft32(u, 7)
3537
u = x4 + x0
36-
x8 ^= u<<9 | u>>(32-9)
38+
x8 ^= bits.RotateLeft32(u, 9)
3739
u = x8 + x4
38-
x12 ^= u<<13 | u>>(32-13)
40+
x12 ^= bits.RotateLeft32(u, 13)
3941
u = x12 + x8
40-
x0 ^= u<<18 | u>>(32-18)
42+
x0 ^= bits.RotateLeft32(u, 18)
4143

4244
u = x5 + x1
43-
x9 ^= u<<7 | u>>(32-7)
45+
x9 ^= bits.RotateLeft32(u, 7)
4446
u = x9 + x5
45-
x13 ^= u<<9 | u>>(32-9)
47+
x13 ^= bits.RotateLeft32(u, 9)
4648
u = x13 + x9
47-
x1 ^= u<<13 | u>>(32-13)
49+
x1 ^= bits.RotateLeft32(u, 13)
4850
u = x1 + x13
49-
x5 ^= u<<18 | u>>(32-18)
51+
x5 ^= bits.RotateLeft32(u, 18)
5052

5153
u = x10 + x6
52-
x14 ^= u<<7 | u>>(32-7)
54+
x14 ^= bits.RotateLeft32(u, 7)
5355
u = x14 + x10
54-
x2 ^= u<<9 | u>>(32-9)
56+
x2 ^= bits.RotateLeft32(u, 9)
5557
u = x2 + x14
56-
x6 ^= u<<13 | u>>(32-13)
58+
x6 ^= bits.RotateLeft32(u, 13)
5759
u = x6 + x2
58-
x10 ^= u<<18 | u>>(32-18)
60+
x10 ^= bits.RotateLeft32(u, 18)
5961

6062
u = x15 + x11
61-
x3 ^= u<<7 | u>>(32-7)
63+
x3 ^= bits.RotateLeft32(u, 7)
6264
u = x3 + x15
63-
x7 ^= u<<9 | u>>(32-9)
65+
x7 ^= bits.RotateLeft32(u, 9)
6466
u = x7 + x3
65-
x11 ^= u<<13 | u>>(32-13)
67+
x11 ^= bits.RotateLeft32(u, 13)
6668
u = x11 + x7
67-
x15 ^= u<<18 | u>>(32-18)
69+
x15 ^= bits.RotateLeft32(u, 18)
6870

6971
u = x0 + x3
70-
x1 ^= u<<7 | u>>(32-7)
72+
x1 ^= bits.RotateLeft32(u, 7)
7173
u = x1 + x0
72-
x2 ^= u<<9 | u>>(32-9)
74+
x2 ^= bits.RotateLeft32(u, 9)
7375
u = x2 + x1
74-
x3 ^= u<<13 | u>>(32-13)
76+
x3 ^= bits.RotateLeft32(u, 13)
7577
u = x3 + x2
76-
x0 ^= u<<18 | u>>(32-18)
78+
x0 ^= bits.RotateLeft32(u, 18)
7779

7880
u = x5 + x4
79-
x6 ^= u<<7 | u>>(32-7)
81+
x6 ^= bits.RotateLeft32(u, 7)
8082
u = x6 + x5
81-
x7 ^= u<<9 | u>>(32-9)
83+
x7 ^= bits.RotateLeft32(u, 9)
8284
u = x7 + x6
83-
x4 ^= u<<13 | u>>(32-13)
85+
x4 ^= bits.RotateLeft32(u, 13)
8486
u = x4 + x7
85-
x5 ^= u<<18 | u>>(32-18)
87+
x5 ^= bits.RotateLeft32(u, 18)
8688

8789
u = x10 + x9
88-
x11 ^= u<<7 | u>>(32-7)
90+
x11 ^= bits.RotateLeft32(u, 7)
8991
u = x11 + x10
90-
x8 ^= u<<9 | u>>(32-9)
92+
x8 ^= bits.RotateLeft32(u, 9)
9193
u = x8 + x11
92-
x9 ^= u<<13 | u>>(32-13)
94+
x9 ^= bits.RotateLeft32(u, 13)
9395
u = x9 + x8
94-
x10 ^= u<<18 | u>>(32-18)
96+
x10 ^= bits.RotateLeft32(u, 18)
9597

9698
u = x15 + x14
97-
x12 ^= u<<7 | u>>(32-7)
99+
x12 ^= bits.RotateLeft32(u, 7)
98100
u = x12 + x15
99-
x13 ^= u<<9 | u>>(32-9)
101+
x13 ^= bits.RotateLeft32(u, 9)
100102
u = x13 + x12
101-
x14 ^= u<<13 | u>>(32-13)
103+
x14 ^= bits.RotateLeft32(u, 13)
102104
u = x14 + x13
103-
x15 ^= u<<18 | u>>(32-18)
105+
x15 ^= bits.RotateLeft32(u, 18)
104106
}
105107
out[0] = byte(x0)
106108
out[1] = byte(x0 >> 8)

0 commit comments

Comments
 (0)