gost28147/cbc_test.go              |  2 +-
 gost28147/cfb.go                   |  4 ++--
 gost28147/cipher_test.go           |  3 +--
 gost28147/ctr.go                   |  2 +-
 gost28147/ctr_test.go              |  3 +--
 gost28147/mac.go                   |  7 +++----
 gost28147/mac_test.go              |  7 +++----
 gost28147/wrap.go                  |  4 ++--
 gost28147/wrap_test.go             |  2 +-
 gost3410/2001_test.go              |  6 ++----
 gost3410/2012_test.go              |  6 ++----
 gost3410/private.go                |  6 +++---
 gost3410/public.go                 |  8 ++++----
 gost3410/ukm.go                    |  2 +-
 gost341194/hash.go                 |  4 ++--
 gost341194/hash_test.go            |  7 +++----
 gost3412128/cipher.go              | 20 ++++++++++----------
 gost3412128/cipher_test.go         |  8 +++-----
 gost341264/cipher.go               |  2 +-
 internal/gost34112012/hash.go      |  8 ++++----
 internal/gost34112012/hash_test.go |  5 ++---
 mgm/mode.go                        |  4 ++--
 mgm/mode_test.go                   |  6 ++----
 mgm/mul128.go                      |  2 +-
 mgm/mul128_test.go                 |  3 +--
 mgm/mul64_test.go                  |  3 +--
 prfplus/plus.go                    |  2 +-

diff --git a/gost28147/cbc_test.go b/gost28147/cbc_test.go
index 965721ef32e1a2b80da606889062814effad5a5ab0f2a9e452077e0af50d5bc6..ae0c3170cf4259bdb645d135a7ec1229c5aa12f9b460d5b155f9efd60b4c8ece 100644
--- a/gost28147/cbc_test.go
+++ b/gost28147/cbc_test.go
@@ -25,7 +25,7 @@
 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 64b665e4336356165eb8ff772e26e86d3770b35b0c205452c92ee5093e74605e..d7749f47c5fb610a705c993c2f381355ab84073c2a9154ea05d6eeb7be23a1b3 100644
--- a/gost28147/cfb.go
+++ b/gost28147/cfb.go
@@ -35,7 +35,7 @@ 	i := 0
 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 @@ 	i := 0
 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 d5f0b91da8ff4f5208ff70846a7536770c4c5d18628c89353e0b91cc34af5a40..3be1e2319654a852c40b490cfd08e0f29f3576d887444254f8787c77fc4b1bf8 100644
--- a/gost28147/cipher_test.go
+++ b/gost28147/cipher_test.go
@@ -32,8 +32,7 @@ 	dst := make([]byte, BlockSize)
 	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 066616daab3713f54259787c3f3f32626e5276a298c86916322b52420f087c45..ff9c0ea2cf0138770c09ce725ae27cb6aada26cbcec036b097f9ecb55fb216ed 100644
--- a/gost28147/ctr.go
+++ b/gost28147/ctr.go
@@ -45,7 +45,7 @@ 			c.n2 -= 1<<32 - 1
 		}
 		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 1d29f292421607f5ea23875c691d99b34c5f89e564a5b75d93632aa95293408c..14fdd30e09ede1175ba6eeb990f8f4a4855e5b6602448b5de885b39e60892c2e 100644
--- a/gost28147/ctr_test.go
+++ b/gost28147/ctr_test.go
@@ -190,8 +190,7 @@ 	src := make([]byte, BlockSize)
 	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 a5b8e81c3ce9efb58f6a1655ebea8bd3f4012d7b50f913810d10feb24c420ed5..760736230a6aff3bd76fe1473c9317af2c8845a37fce791bb06f35bf01aa5250 100644
--- a/gost28147/mac.go
+++ b/gost28147/mac.go
@@ -70,7 +70,7 @@
 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 @@ 	if len(m.buf) == 0 {
 		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 ee37d478bace111420f4895c941936bfbea32056bcc89fc02e991143c2c04ce2..5e54430017de8775cb5ecc61ab0abf5798952a769c0d8edf3eb0df4e14eccd13 100644
--- a/gost28147/mac_test.go
+++ b/gost28147/mac_test.go
@@ -49,7 +49,7 @@ 	})
 
 	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 @@ 	})
 
 	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 @@ 	rand.Read(b1)
 	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 9622b6f396a4dd2c75e74b070e632b9883f3752ea68e099f62af6d38876cbf71..9e21ab13ace9a43bbcfa02ce0724c5332d7f39004e1b3424994364770a2dc1d7 100644
--- a/gost28147/wrap.go
+++ b/gost28147/wrap.go
@@ -59,9 +59,9 @@ }
 
 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 700949ef32b3406e02e5ed7533ce94824acd1c8a943b4468faad694b9ef673bd..b56e7516ba685648ec846e10a0c2369d99d95e4e63b2baefda83e74529172e8e 100644
--- 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 5a4eb0a8578eff9ac2b70d4d766c331d824af35c6d0db0c65817b439e64331d6..6d5d2cd59f21c91e1be4a429cda3768e4661b48aea189a890009cc548ff26721 100644
--- a/gost3410/2001_test.go
+++ b/gost3410/2001_test.go
@@ -126,8 +126,7 @@ 		b.Fatal(err)
 	}
 	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 @@ 	pub, err := prv.PublicKey()
 	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 10486cc7420df539e7201a00bc0a4647a54cdf3d61fcd134f45c63a217dc895e..ae64de4d47cc687d6c413c626d7002dd55c144ab5fe8d61c16199ad5befd766e 100644
--- a/gost3410/2012_test.go
+++ b/gost3410/2012_test.go
@@ -590,8 +590,7 @@ 		b.Fatal(err)
 	}
 	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 @@ 	pub, err := prv.PublicKey()
 	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 0078f8dc7f400c7944ec51c8bd43be6a7af91281ab4178f3136e94ff4e47daa9..d38d9695317f24d30a4e72666e3ebb5369bf9c68a581eab64262a2fd51eacf4d 100644
--- a/gost3410/private.go
+++ b/gost3410/private.go
@@ -35,7 +35,7 @@ 	if len(raw) != pointSize {
 		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 6cb1cb067f2f8a7f7b24f36b20a5d107a9f8782fe5e705d7c6f745584632be84..6261cd798cde12b9a205066c130ded5b13eea7030568fafc405b03b608b231f2 100644
--- a/gost3410/public.go
+++ b/gost3410/public.go
@@ -33,7 +33,7 @@ 	key := make([]byte, 2*pointSize)
 	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 33e427eb66a523625723a0ed750599b6169018e4fca4bbcb10ec27adf5b04d14..4326421585d71b2f2ca6fa6035adfd4576f52042f23c63e0b7be9794e9d6b729 100644
--- a/gost3410/ukm.go
+++ b/gost3410/ukm.go
@@ -22,7 +22,7 @@
 // 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 f9297e10ec3b8c7a9314692a729545f4d016609d466476efd9ef8ce52b27d309..85cc9ebf32d85123c5ae5a98136252708ce9ed80bea7097caae644098a6fac58 100644
--- a/gost341194/hash.go
+++ b/gost341194/hash.go
@@ -210,13 +210,13 @@ 	out[2] = s[5]
 	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 15d3c499958a6985cdd0d6a99a675ad4ccdd033d2ef54127dd89826e88a7657e..10953661055cb5df01d238b86bf543df01a034eee8cd329bb14fc8ea9c63a80c 100644
--- a/gost341194/hash_test.go
+++ b/gost341194/hash_test.go
@@ -83,7 +83,7 @@ }
 
 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 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 f53d770b7ef63f78b5e286077213731297a5c4b56d9adfee4d61460ce1c20779..877003434e7faa06fbe192067c2a3bd56cb48eb79273e7ab748ad0a903e1274d 100644
--- a/gost3412128/cipher.go
+++ b/gost3412128/cipher.go
@@ -74,7 +74,7 @@ 	return
 }
 
 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 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 @@ 	blk[15] = pi[int(blk[15])]
 }
 
 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 @@ 	copy(kr0[:], key[:BlockSize])
 	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 (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 8ceb5d8d47d9adf3ea67d228c1b7550f9f2be7679ddaa699848f6355c40bc278..335abc6a259538d50a2ddc84939ab2757e197805cdc108398915d93e3fcc4ddf 100644
--- a/gost3412128/cipher_test.go
+++ b/gost3412128/cipher_test.go
@@ -64,8 +64,7 @@ 	key := make([]byte, KeySize)
 	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 @@ 	key := make([]byte, KeySize)
 	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 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 861df429c69c8fa010b6ec757f6df9a2cc7a849aaa4d9cf1da5140b439a93a60..9878cbcbf0bb1775bfa6df0d38388e860afa9fd6bc439b5af385a7ef7b44078a 100644
--- a/gost341264/cipher.go
+++ b/gost341264/cipher.go
@@ -35,7 +35,7 @@ 	if len(key) != KeySize {
 		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 e96221e712f9a40d68c09678d51afa21384f57ff6aff35dd1c18ab9a392397b0..4bb681ba7ff894d5db66dad9188a99f0128d1c5588b8e05db252a5433ea27e09 100644
--- 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 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 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 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 7e35a5218b3f32da81c994eab29629c187629abf410e26e0beb505f9ab16884f..de8da9229469edc9fad92114beb8d24ce71b98d5838e76a1f884dd3bfb2835f2 100644
--- a/internal/gost34112012/hash_test.go
+++ b/internal/gost34112012/hash_test.go
@@ -147,7 +147,7 @@
 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 08de64199577a2af1f42c96559d2db7b25db4c2bfe432dbbf7e258735d8556c2..a4b6add84358a0581671e2fa0d0c020edce26ac54dfcb80a51e933b83c473aa4 100644
--- a/mgm/mode.go
+++ b/mgm/mode.go
@@ -174,7 +174,7 @@ 	mgm.cipher.Encrypt(mgm.bufP, mgm.icn) // Y_1 = E_K(0 || ICN)
 	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 @@ 		in = in[mgm.BlockSize:]
 	}
 	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 36f5704db165a7db982b257bbdba42616b484e8e3b26377d3b36b30b1e6452b9..9cdc47905bd550d599e784e76388d5a785ae15db253c90fa0559198197ab3d73 100644
--- a/mgm/mode_test.go
+++ b/mgm/mode_test.go
@@ -165,8 +165,7 @@ 	if err != nil {
 		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 @@ 	if err != nil {
 		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 7e7eda7c425e96f5e97e8355bd51db18920ffdc84885c21c3ca2896da707a0d2..6bb87f3115187b44d30162790ebfb9b93acb3c95b36cca87cff8bccb57ae4589 100644
--- a/mgm/mul128.go
+++ b/mgm/mul128.go
@@ -25,7 +25,7 @@ }
 
 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 191d635314a7bf69a557a7bab302a09846417552d0b0d41dc65ba782d40968e6..afbd675922eb28a0b68ef5ab15b1db1c37187317f2267b9ceed3ce87354f23e1 100644
--- a/mgm/mul128_test.go
+++ b/mgm/mul128_test.go
@@ -28,8 +28,7 @@ 	y := make([]byte, gost3412128.BlockSize)
 	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 abb458874423a5be0a77cdbcd6a4e406a276adb6d1bc777c07fd19c061b6c662..204683fd767111c82661b8bb221198dce4cadc11ca194debc5198b0494fb6229 100644
--- a/mgm/mul64_test.go
+++ b/mgm/mul64_test.go
@@ -28,8 +28,7 @@ 	y := make([]byte, gost341264.BlockSize)
 	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 1029b28734274ee97ef7379e71cc30210d550d16193c0ba37d897e81e392cea2..fd19dd6277218371dc185d8872ccfcac8c309ec5b28f06d24e256300b538f519 100644
--- a/prfplus/plus.go
+++ b/prfplus/plus.go
@@ -36,7 +36,7 @@ 		n++
 	}
 	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()])