Modernise the code

diff --git a/gost28147/cbc_test.go b/gost28147/cbc_test.go
index 8179b16894f0ca4994f44bf4cbc05803d5b522e0..11bebda6c59b69f832903a08fdb9197e02acb47c 100644 (file)
--- a/gost28147/cbc_test.go
+++ b/gost28147/cbc_test.go
@@ -25,7 +25,7 @@ import (
 func TestCBCCrypter(t *testing.T) {
        f := func(key [KeySize]byte, iv [BlockSize]byte, pt []byte) bool {
                c := NewCipher(key[:], SboxDefault)
-               for i := 0; i < BlockSize; i++ {
+               for range BlockSize {
                        pt = append(pt, pt...)
                }
                ct := make([]byte, len(pt))

diff --git a/gost28147/cfb.go b/gost28147/cfb.go
index 7076f3fd11a253a226c6b6b371726d9c40b62a83..4312575f4cb8ff5cc59144fe56c351bcc729b0dd 100644 (file)
--- a/gost28147/cfb.go
+++ b/gost28147/cfb.go
@@ -35,7 +35,7 @@ func (c *CFBEncrypter) XORKeyStream(dst, src []byte) {
 MainLoop:
        for {
                c.c.Encrypt(c.iv, c.iv)
-               for n = 0; n < BlockSize; n++ {
+               for n = range BlockSize {
                        if i*BlockSize+n == len(src) {
                                break MainLoop
                        }
@@ -66,7 +66,7 @@ func (c *CFBDecrypter) XORKeyStream(dst, src []byte) {
 MainLoop:
        for {
                c.c.Encrypt(c.iv, c.iv)
-               for n = 0; n < BlockSize; n++ {
+               for n = range BlockSize {
                        if i*BlockSize+n == len(src) {
                                break MainLoop
                        }

diff --git a/gost28147/cipher_test.go b/gost28147/cipher_test.go
index 828dc6e2ced6bc4bea688e0194b12e120f3df496..02b7261ea58f64095af7ff7a7d8da2540d2bb6d3 100644 (file)
--- a/gost28147/cipher_test.go
+++ b/gost28147/cipher_test.go
@@ -32,8 +32,7 @@ func BenchmarkCipher(b *testing.B) {
        src := make([]byte, BlockSize)
        rand.Read(src)
        c := NewCipher(key[:], SboxDefault)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                c.Encrypt(dst, src)
        }
 }

diff --git a/gost28147/ctr.go b/gost28147/ctr.go
index dfb37428b75ce49a7f70ddde51e0f66c2679ac3b..07cfcf7781b2d956aaac8c8f36a78e159180de53 100644 (file)
--- a/gost28147/ctr.go
+++ b/gost28147/ctr.go
@@ -45,7 +45,7 @@ MainLoop:
                }
                n1t, n2t = c.c.xcrypt(SeqEncrypt, c.n1, c.n2)
                nvs2block(n1t, n2t, block)
-               for n = 0; n < BlockSize; n++ {
+               for n = range BlockSize {
                        if i*BlockSize+n == len(src) {
                                break MainLoop
                        }

diff --git a/gost28147/ctr_test.go b/gost28147/ctr_test.go
index baa72aae76e1a4783318f1994ebc25117a353ef9..195786f699ea8d31009c8e45c1ad4ab4c97f1d1c 100644 (file)
--- a/gost28147/ctr_test.go
+++ b/gost28147/ctr_test.go
@@ -190,8 +190,7 @@ func BenchmarkCTR(b *testing.B) {
        rand.Read(src)
        c := NewCipher(key, SboxDefault)
        ctr := c.NewCTR(iv)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                ctr.XORKeyStream(dst, src)
        }
 }

diff --git a/gost28147/mac.go b/gost28147/mac.go
index 46f2e1ac4beefb7fb84c092edc0a183027c55346..6fe039d88c988635a8650d61a4e9addb42dfd1ba 100644 (file)
--- a/gost28147/mac.go
+++ b/gost28147/mac.go
@@ -70,7 +70,7 @@ func (m *MAC) Size() int {
 func (m *MAC) Write(b []byte) (int, error) {
        m.buf = append(m.buf, b...)
        for len(m.buf) >= BlockSize {
-               for i := 0; i < BlockSize; i++ {
+               for i := range BlockSize {
                        m.prev[i] ^= m.buf[i]
                }
                m.n1, m.n2 = block2nvs(m.prev)
@@ -86,11 +86,10 @@ func (m *MAC) Sum(b []byte) []byte {
                return append(b, m.prev[0:m.size]...)
        }
        buf := m.buf
-       var i int
-       for i = 0; i < BlockSize-len(m.buf); i++ {
+       for range BlockSize - len(m.buf) {
                buf = append(buf, byte(0))
        }
-       for i = 0; i < BlockSize; i++ {
+       for i := range BlockSize {
                buf[i] ^= m.prev[i]
        }
        m.n1, m.n2 = block2nvs(buf)

diff --git a/gost28147/mac_test.go b/gost28147/mac_test.go
index f37e9c67dbebdd7fb42036eb471075a7d1425e1f..69f734286207d57b685aa9ccaa7704d0a1e71db4 100644 (file)
--- a/gost28147/mac_test.go
+++ b/gost28147/mac_test.go
@@ -49,7 +49,7 @@ func TestMACVectors(t *testing.T) {
 
        t.Run("128U", func(t *testing.T) {
                m.Reset()
-               for i := 0; i < 128; i++ {
+               for range 128 {
                        m.Write([]byte("U"))
                }
                if !bytes.Equal(m.Sum(nil), []byte{0x1a, 0x06, 0xd1, 0xba, 0xd7, 0x45, 0x80, 0xef}) {
@@ -59,7 +59,7 @@ func TestMACVectors(t *testing.T) {
 
        t.Run("xxxxxxxxxxxxx", func(t *testing.T) {
                m.Reset()
-               for i := 0; i < 13; i++ {
+               for range 13 {
                        m.Write([]byte("x"))
                }
                if !bytes.Equal(m.Sum(nil), []byte{0x91, 0x7e, 0xe1, 0xf1, 0xa6, 0x68, 0xfb, 0xd3}) {
@@ -119,8 +119,7 @@ func BenchmarkMAC(b *testing.B) {
        rand.Read(b2)
        c := NewCipher(key[:], SboxDefault)
        mac, _ := c.NewMAC(BlockSize, iv)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                mac.Write(b1)
                mac.Write(b2)
                mac.Sum(nil)

diff --git a/gost28147/wrap.go b/gost28147/wrap.go
index 24190ea97d79919bc672d0cf93e50a09b499b79e..1f23224454b48d116491e62dd6377153af5e30e4 100644 (file)
--- a/gost28147/wrap.go
+++ b/gost28147/wrap.go
@@ -59,9 +59,9 @@ func UnwrapGost(kek, data []byte) []byte {
 
 func DiversifyCryptoPro(kek, ukm []byte) []byte {
        out := kek
-       for i := 0; i < 8; i++ {
+       for i := range 8 {
                var s1, s2 uint64
-               for j := 0; j < 8; j++ {
+               for j := range 8 {
                        k := binary.LittleEndian.Uint32(out[j*4 : j*4+4])
                        if (ukm[i]>>j)&1 > 0 {
                                s1 += uint64(k)

diff --git a/gost28147/wrap_test.go b/gost28147/wrap_test.go
index 9cf066b6fdc83cb0f6b375810cb72198b5a0d458..2d144cdd04bd565a2c5033b7a7a2d9bee7a79f74 100644 (file)
--- a/gost28147/wrap_test.go
+++ b/gost28147/wrap_test.go
@@ -11,7 +11,7 @@ func TestWrapSymmetric(t *testing.T) {
        kek := make([]byte, KeySize)
        cek := make([]byte, KeySize)
        ukm := make([]byte, 8)
-       for i := 0; i < 1000; i++ {
+       for range 1000 {
                if _, err := io.ReadFull(rand.Reader, kek); err != nil {
                        t.Fatal(err)
                }

diff --git a/gost3410/2001_test.go b/gost3410/2001_test.go
index 0aed3a24f3aacce6889837c6b1f33403467b30ce..079fd20609c023f93682503ce301ac8b1882556a 100644 (file)
--- a/gost3410/2001_test.go
+++ b/gost3410/2001_test.go
@@ -126,8 +126,7 @@ func BenchmarkSign2001(b *testing.B) {
        }
        digest := make([]byte, 32)
        rand.Read(digest)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                prv.SignDigest(digest, rand.Reader)
        }
 }
@@ -148,8 +147,7 @@ func BenchmarkVerify2001(b *testing.B) {
        if err != nil {
                b.Fatal(err)
        }
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                pub.VerifyDigest(digest, sign)
        }
 }

diff --git a/gost3410/2012_test.go b/gost3410/2012_test.go
index 93ef3b385bc44d1ae179d2a3053658331c00ff4d..0b8fe13620796c18761e83e82edd7000850513d7 100644 (file)
--- a/gost3410/2012_test.go
+++ b/gost3410/2012_test.go
@@ -590,8 +590,7 @@ func BenchmarkSign2012(b *testing.B) {
        }
        digest := make([]byte, 64)
        rand.Read(digest)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                prv.SignDigest(digest, rand.Reader)
        }
 }
@@ -612,8 +611,7 @@ func BenchmarkVerify2012(b *testing.B) {
        if err != nil {
                b.Fatal(err)
        }
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                pub.VerifyDigest(digest, sign)
        }
 }

diff --git a/gost3410/private.go b/gost3410/private.go
index d5eaf8242c2021a6ceccfb61e48fbdf90167f92a..ab03e4d1bf96bd5874d590840f485c6492b8da3a 100644 (file)
--- a/gost3410/private.go
+++ b/gost3410/private.go
@@ -35,7 +35,7 @@ func NewPrivateKeyLE(c *Curve, raw []byte) (*PrivateKey, error) {
                return nil, fmt.Errorf("gogost/gost3410: len(key)=%d != %d", len(raw), pointSize)
        }
        key := make([]byte, pointSize)
-       for i := 0; i < len(key); i++ {
+       for i := range len(key) {
                key[i] = raw[len(raw)-i-1]
        }
        k := bytes2big(key)
@@ -167,7 +167,7 @@ func (prv *PrivateKeyReverseDigest) Sign(
        rand io.Reader, digest []byte, opts crypto.SignerOpts,
 ) ([]byte, error) {
        dgst := make([]byte, len(digest))
-       for i := 0; i < len(digest); i++ {
+       for i := range len(digest) {
                dgst[i] = digest[len(digest)-i-1]
        }
        return prv.Prv.Sign(rand, dgst, opts)
@@ -185,7 +185,7 @@ func (prv *PrivateKeyReverseDigestAndSignature) Sign(
        rand io.Reader, digest []byte, opts crypto.SignerOpts,
 ) ([]byte, error) {
        dgst := make([]byte, len(digest))
-       for i := 0; i < len(digest); i++ {
+       for i := range len(digest) {
                dgst[i] = digest[len(digest)-i-1]
        }
        sign, err := prv.Prv.Sign(rand, dgst, opts)

diff --git a/gost3410/public.go b/gost3410/public.go
index 485722e740e4cd057856c0776db724c81d423bff..932885912ccf2f6e09c30dbb297a3638b9360564 100644 (file)
--- a/gost3410/public.go
+++ b/gost3410/public.go
@@ -33,7 +33,7 @@ func NewPublicKeyLE(c *Curve, raw []byte) (*PublicKey, error) {
        if len(raw) != len(key) {
                return nil, fmt.Errorf("gogost/gost3410: len(key) != %d", len(key))
        }
-       for i := 0; i < len(key); i++ {
+       for i := range len(key) {
                key[i] = raw[len(raw)-i-1]
        }
        return &PublicKey{
@@ -158,7 +158,7 @@ func (pub PublicKeyReverseDigest) VerifyDigest(
        digest, signature []byte,
 ) (bool, error) {
        dgst := make([]byte, len(digest))
-       for i := 0; i < len(digest); i++ {
+       for i := range len(digest) {
                dgst[i] = digest[len(digest)-i-1]
        }
        return pub.Pub.VerifyDigest(dgst, signature)
@@ -176,11 +176,11 @@ func (pub PublicKeyReverseDigestAndSignature) VerifyDigest(
        digest, signature []byte,
 ) (bool, error) {
        dgst := make([]byte, len(digest))
-       for i := 0; i < len(digest); i++ {
+       for i := range len(digest) {
                dgst[i] = digest[len(digest)-i-1]
        }
        sign := make([]byte, len(signature))
-       for i := 0; i < len(signature); i++ {
+       for i := range len(signature) {
                sign[i] = signature[len(signature)-i-1]
        }
        return pub.Pub.VerifyDigest(dgst, sign)

diff --git a/gost3410/ukm.go b/gost3410/ukm.go
index 369498e62b1bafd71caf19e9f6e75e3d1034d738..804520ea22f6c408eaa8fe8fc39b606e013b4115 100644 (file)
--- a/gost3410/ukm.go
+++ b/gost3410/ukm.go
@@ -22,7 +22,7 @@ import (
 // Unmarshal little-endian UKM value.
 func NewUKM(raw []byte) *big.Int {
        t := make([]byte, len(raw))
-       for i := 0; i < len(t); i++ {
+       for i := range len(t) {
                t[i] = raw[len(raw)-i-1]
        }
        return bytes2big(t)

diff --git a/gost341194/hash.go b/gost341194/hash.go
index 4b7e13a919ec694eec8b51573b0ffb9f6be2fb81..fcb64dca9b150e793c544d7ed6d81ce5691041d0 100644 (file)
--- a/gost341194/hash.go
+++ b/gost341194/hash.go
@@ -210,13 +210,13 @@ func (h *Hash) step(hin, m [BlockSize]byte) [BlockSize]byte {
        out[1] = s[6]
        out[0] = s[7]
 
-       for i := 0; i < 12; i++ {
+       for range 12 {
                out = fChi(out)
        }
        blockXor(out, out, &m)
        out = fChi(out)
        blockXor(out, out, &hin)
-       for i := 0; i < 61; i++ {
+       for range 61 {
                out = fChi(out)
        }
        return *out

diff --git a/gost341194/hash_test.go b/gost341194/hash_test.go
index f86d54ce967afbd842e3f768478dc7ed7d173531..33e6e5095c64f7aebe52ef5b853b4e7f1e6b8d7a 100644 (file)
--- a/gost341194/hash_test.go
+++ b/gost341194/hash_test.go
@@ -83,7 +83,7 @@ func TestVectorsMessageDigest(t *testing.T) {
 
 func TestVectors128U(t *testing.T) {
        h := New(SboxDefault)
-       for i := 0; i < 128; i++ {
+       for range 128 {
                h.Write([]byte("U"))
        }
        if !bytes.Equal(h.Sum(nil), []byte{
@@ -240,7 +240,7 @@ func TestVectorsCryptoPro50(t *testing.T) {
 
 func TestVectorsCryptoPro128U(t *testing.T) {
        h := New(&gost28147.SboxIdGostR341194CryptoProParamSet)
-       for i := 0; i < 128; i++ {
+       for range 128 {
                h.Write([]byte{'U'})
        }
        if !bytes.Equal(h.Sum(nil), []byte{
@@ -275,8 +275,7 @@ func BenchmarkHash(b *testing.B) {
        h := New(SboxDefault)
        src := make([]byte, BlockSize+1)
        rand.Read(src)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                h.Write(src)
                h.Sum(nil)
        }

diff --git a/gost3412128/cipher.go b/gost3412128/cipher.go
index 56c320adffe2b805bcc010d0443cc83655f6e99c..9584c0fa48cb9ee5e6ce9a8b669788e3f9104806 100644 (file)
--- a/gost3412128/cipher.go
+++ b/gost3412128/cipher.go
@@ -74,7 +74,7 @@ func gf(a, b byte) (c byte) {
 }
 
 func l(blk *[BlockSize]byte) {
-       for n := 0; n < BlockSize; n++ {
+       for range BlockSize {
                blk[0],
                        blk[1],
                        blk[2],
@@ -126,7 +126,7 @@ func l(blk *[BlockSize]byte) {
 
 func lInv(blk *[BlockSize]byte) {
        var t byte
-       for n := 0; n < BlockSize; n++ {
+       for range BlockSize {
                t = blk[0]
                copy(blk[:], blk[1:])
                t ^= gfCache[blk[0]][lc[0]]
@@ -168,21 +168,21 @@ func s(blk *[BlockSize]byte) {
 }
 
 func sInv(blk *[BlockSize]byte) {
-       for n := 0; n < BlockSize; n++ {
+       for n := range BlockSize {
                blk[n] = piInv[int(blk[n])]
        }
 }
 
 func init() {
-       for a := 0; a < 256; a++ {
-               for b := 0; b < 256; b++ {
+       for a := range 256 {
+               for b := range 256 {
                        gfCache[a][b] = gf(byte(a), byte(b))
                }
        }
-       for i := 0; i < 256; i++ {
+       for i := range 256 {
                piInv[int(pi[i])] = byte(i)
        }
-       for i := 0; i < 32; i++ {
+       for i := range 32 {
                cBlk[i] = new([BlockSize]byte)
                cBlk[i][15] = byte(i) + 1
                l(cBlk[i])
@@ -209,8 +209,8 @@ func NewCipher(key []byte) *Cipher {
        copy(kr1[:], key[BlockSize:])
        copy(ks[0][:], kr0[:])
        copy(ks[1][:], kr1[:])
-       for i := 0; i < 4; i++ {
-               for j := 0; j < 8; j++ {
+       for i := range 4 {
+               for j := range 8 {
                        subtle.XORBytes(krt[:], kr0[:], cBlk[8*i+j][:])
                        s(&krt)
                        l(&krt)
@@ -227,7 +227,7 @@ func NewCipher(key []byte) *Cipher {
 func (c *Cipher) Encrypt(dst, src []byte) {
        blk := new([BlockSize]byte)
        copy(blk[:], src)
-       for i := 0; i < 9; i++ {
+       for i := range 9 {
                subtle.XORBytes(blk[:], blk[:], c.ks[i][:])
                s(blk)
                l(blk)

diff --git a/gost3412128/cipher_test.go b/gost3412128/cipher_test.go
index 1483362575c6fc95957e50c70026c072f454e1d1..589198bd2ec8ab358863860ce6935522bb1effef 100644 (file)
--- a/gost3412128/cipher_test.go
+++ b/gost3412128/cipher_test.go
@@ -64,8 +64,7 @@ func BenchmarkEncrypt(b *testing.B) {
        io.ReadFull(rand.Reader, key)
        c := NewCipher(key)
        blk := make([]byte, BlockSize)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                c.Encrypt(blk, blk)
        }
 }
@@ -75,8 +74,7 @@ func BenchmarkDecrypt(b *testing.B) {
        io.ReadFull(rand.Reader, key)
        c := NewCipher(key)
        blk := make([]byte, BlockSize)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                c.Decrypt(blk, blk)
        }
 }
@@ -118,7 +116,7 @@ func TestS(t *testing.T) {
 
 func R(blk []byte) {
        t := blk[15]
-       for i := 0; i < 15; i++ {
+       for i := range 15 {
                t ^= gfCache[blk[i]][lc[i]]
        }
        copy(blk[1:], blk)

diff --git a/gost341264/cipher.go b/gost341264/cipher.go
index 140940489b9a9614268715ddc8fcf692954d18b0..58b75d2b2d306959fdcbc2319dc9f86d4b848125 100644 (file)
--- a/gost341264/cipher.go
+++ b/gost341264/cipher.go
@@ -35,7 +35,7 @@ func NewCipher(key []byte) *Cipher {
                panic("invalid key size")
        }
        keyCompatible := make([]byte, KeySize)
-       for i := 0; i < KeySize/4; i++ {
+       for i := range KeySize / 4 {
                keyCompatible[i*4+0] = key[i*4+3]
                keyCompatible[i*4+1] = key[i*4+2]
                keyCompatible[i*4+2] = key[i*4+1]

diff --git a/internal/gost34112012/hash.go b/internal/gost34112012/hash.go
index 2e1369b07efb8719af6c63ace4a43c5c3cd137bd..cb7fdc6c51a44a6929bcdc2e45c61c6215c8dbe6 100644 (file)
--- a/internal/gost34112012/hash.go
+++ b/internal/gost34112012/hash.go
@@ -50,7 +50,7 @@ func (h *Hash) Reset() {
        h.n = 0
        h.buf = nil
        clear(h.chk)
-       for i := 0; i < BlockSize; i++ {
+       for i := range BlockSize {
                if h.size == 32 {
                        h.hsh[i] = 1
                } else {
@@ -69,7 +69,7 @@ func (h *Hash) Size() int {
 
 func add512bit(out, chk, data []byte) []byte {
        var ss uint16
-       for i := 0; i < BlockSize; i++ {
+       for i := range BlockSize {
                ss = uint16(chk[i]) + uint16(data[i]) + (ss >> 8)
                out[i] = byte(0xFF & ss)
        }
@@ -78,7 +78,7 @@ func add512bit(out, chk, data []byte) []byte {
 
 func lps(out, data []byte) {
        var res [BlockSize]byte
-       for i := 0; i < 8; i++ {
+       for i := range 8 {
                binary.LittleEndian.PutUint64(res[i*8:i*8+8],
                        precalc[0][data[8*0+i]]^
                                precalc[1][data[8*1+i]]^
@@ -112,7 +112,7 @@ func (h *Hash) g(dst []byte, n uint64, hsh, data []byte) {
 
 func e(out, k, msg []byte) {
        var msgBuf, kBuf, xorBuf [BlockSize]byte
-       for i := 0; i < 12; i++ {
+       for i := range 12 {
                subtle.XORBytes(xorBuf[:], k, msg)
                lps(msgBuf[:], xorBuf[:])
                msg = msgBuf[:]

diff --git a/internal/gost34112012/hash_test.go b/internal/gost34112012/hash_test.go
index f5b726d2e3211193765acdd2cf5f9ac4ec917236..1bd728c11b3f66f62b0ad188795474ad2fd2433f 100644 (file)
--- a/internal/gost34112012/hash_test.go
+++ b/internal/gost34112012/hash_test.go
@@ -147,7 +147,7 @@ func TestVectors(t *testing.T) {
 func TestBlocksized(t *testing.T) {
        h := New(64)
        m := make([]byte, BlockSize)
-       for i := 0; i < BlockSize; i++ {
+       for i := range BlockSize {
                m[i] = byte(i)
        }
        h.Write(m)
@@ -224,8 +224,7 @@ func BenchmarkHash(b *testing.B) {
        h := New(64)
        src := make([]byte, BlockSize+1)
        rand.Read(src)
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                h.Write(src)
                h.Sum(nil)
        }

diff --git a/mgm/mode.go b/mgm/mode.go
index e0aee47a96badc74d557211806237e46741a8a0a..0c7443481455d734a3c20672b7733dd64b6e7c75 100644 (file)
--- a/mgm/mode.go
+++ b/mgm/mode.go
@@ -174,7 +174,7 @@ func (mgm *MGM) crypt(out, in []byte) {
        for len(in) >= mgm.BlockSize {
                mgm.cipher.Encrypt(mgm.bufC, mgm.bufP) // E_K(Y_i)
                // subtle.XORBytes panic because of partial buffer overlapping
-               for i := 0; i < mgm.BlockSize; i++ { // C_i = P_i (xor) E_K(Y_i)
+               for i := range mgm.BlockSize { // C_i = P_i (xor) E_K(Y_i)
                        out[i] = mgm.bufC[i] ^ in[i]
                }
                incr(mgm.bufP[mgm.BlockSize/2:]) // Y_i = incr_r(Y_{i-1})
@@ -183,7 +183,7 @@ func (mgm *MGM) crypt(out, in []byte) {
        }
        if len(in) > 0 {
                mgm.cipher.Encrypt(mgm.bufC, mgm.bufP)
-               for i := 0; i < len(in); i++ {
+               for i := range len(in) {
                        out[i] = in[i] ^ mgm.bufC[i]
                }
        }

diff --git a/mgm/mode_test.go b/mgm/mode_test.go
index 343f9d0cf269d4a8857755821389f02d01d75009..d1f65f740f7e540acd46fffa1e71d70871e01816 100644 (file)
--- a/mgm/mode_test.go
+++ b/mgm/mode_test.go
@@ -165,8 +165,7 @@ func BenchmarkMGM64(b *testing.B) {
                panic(err)
        }
        ct := make([]byte, len(pt)+aead.Overhead())
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                aead.Seal(ct[:0], nonce, pt, nil)
        }
 }
@@ -191,8 +190,7 @@ func BenchmarkMGM128(b *testing.B) {
                panic(err)
        }
        ct := make([]byte, len(pt)+aead.Overhead())
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                aead.Seal(ct[:0], nonce, pt, nil)
        }
 }

diff --git a/mgm/mul128.go b/mgm/mul128.go
index f7de7a38501d5942bf4e1d3c427c05148ac79f18..efdb1733d15f24e88151eb45e18ed02069936e50 100644 (file)
--- a/mgm/mul128.go
+++ b/mgm/mul128.go
@@ -25,7 +25,7 @@ func newMul128() *mul128 {
 
 func gf128half(n int, t, x0, x1, z0, z1 uint64) (uint64, uint64, uint64, uint64, uint64) {
        var sign bool
-       for i := 0; i < n; i++ {
+       for range n {
                if t&1 > 0 {
                        z0, z1 = z0^x0, z1^x1
                }

diff --git a/mgm/mul128_test.go b/mgm/mul128_test.go
index b96c75ca51027068e362ea752b19492468077632..cca00d2a465427330c96bc97015f2f7a56b1468e 100644 (file)
--- a/mgm/mul128_test.go
+++ b/mgm/mul128_test.go
@@ -28,8 +28,7 @@ func BenchmarkMul128(b *testing.B) {
        rand.Read(x)
        rand.Read(y)
        mul := newMul128()
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                mul.Mul(x, y)
        }
 }

diff --git a/mgm/mul64_test.go b/mgm/mul64_test.go
index 2f164343f75f7432953ba12adf536ca0ee8d7625..2399203aa04c3cfcea115885b599979d1a28146c 100644 (file)
--- a/mgm/mul64_test.go
+++ b/mgm/mul64_test.go
@@ -28,8 +28,7 @@ func BenchmarkMul64(b *testing.B) {
        rand.Read(x)
        rand.Read(y)
        mul := newMul64()
-       b.ResetTimer()
-       for i := 0; i < b.N; i++ {
+       for b.Loop() {
                mul.Mul(x, y)
        }
 }

diff --git a/prfplus/plus.go b/prfplus/plus.go
index dc366ee073be64bff888bb146e0ff4d4493af63e..b47eb38feb84fb023d5385ceeaa1dc5be6cc08fb 100644 (file)
--- a/prfplus/plus.go
+++ b/prfplus/plus.go
@@ -36,7 +36,7 @@ func PRFPlus(prf PRFForPlus, dst, salt []byte) {
        }
        n--
        out := dst[prf.BlockSize():]
-       for i := 0; i < n; i++ {
+       for i := range n {
                in[len(in)-1] = byte(i + 2)
                copy(in[:prf.BlockSize()], prf.Derive(in))
                copy(out, in[:prf.BlockSize()])