From: Sergey Matveev <stargrave@stargrave.org>
Date: Wed, 22 Mar 2023 14:20:08 +0000 (+0300)
Subject: Use more modern Go version
X-Git-Tag: v5.10.0~7
X-Git-Url: http://www.git.cypherpunks.ru/?p=gogost.git;a=commitdiff_plain;h=285c03431192ff6ffbfa7470652fd545f06e0b00

Use more modern Go version
---

diff --git a/cmd/cer-selfsigned-example/main.go b/cmd/cer-selfsigned-example/main.go
index 8b79359..2eafe64 100644
--- a/cmd/cer-selfsigned-example/main.go
+++ b/cmd/cer-selfsigned-example/main.go
@@ -216,6 +216,9 @@ func main() {
 		&cerTmpl, caCer, pub,
 		&gost3410.PrivateKeyReverseDigest{Prv: caPrv.(*gost3410.PrivateKey)},
 	)
+	if err != nil {
+		log.Fatalln(err)
+	}
 	data = pem.EncodeToMemory(&pem.Block{Type: PEMCer, Bytes: data})
 	if *outCer == "" {
 		_, err = os.Stdout.Write(data)
diff --git a/go.mod b/go.mod
index 377d625..8d1b937 100644
--- a/go.mod
+++ b/go.mod
@@ -1,5 +1,5 @@
 module go.cypherpunks.ru/gogost/v5
 
-go 1.18
+go 1.20
 
 require golang.org/x/crypto v0.6.0
diff --git a/gost28147/cbc_test.go b/gost28147/cbc_test.go
index ae019b2..06cd020 100644
--- a/gost28147/cbc_test.go
+++ b/gost28147/cbc_test.go
@@ -33,7 +33,7 @@ func TestCBCCrypter(t *testing.T) {
 		e.CryptBlocks(ct, pt)
 		d := cipher.NewCBCDecrypter(c, iv[:])
 		d.CryptBlocks(ct, ct)
-		return bytes.Compare(pt, ct) == 0
+		return bytes.Equal(pt, ct)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost28147/cfb.go b/gost28147/cfb.go
index 9c04da1..d097c99 100644
--- a/gost28147/cfb.go
+++ b/gost28147/cfb.go
@@ -44,7 +44,6 @@ MainLoop:
 		}
 		i++
 	}
-	return
 }
 
 type CFBDecrypter struct {
@@ -76,5 +75,4 @@ MainLoop:
 		}
 		i++
 	}
-	return
 }
diff --git a/gost28147/cfb_test.go b/gost28147/cfb_test.go
index 1f40e45..1e2fad0 100644
--- a/gost28147/cfb_test.go
+++ b/gost28147/cfb_test.go
@@ -43,12 +43,12 @@ func TestCFBCryptomanager(t *testing.T) {
 	tmp := make([]byte, 16)
 	fe := c.NewCFBEncrypter(iv)
 	fe.XORKeyStream(tmp, pt)
-	if bytes.Compare(tmp, ct) != 0 {
+	if !bytes.Equal(tmp, ct) {
 		t.Fatal("encryption failed")
 	}
 	fd := c.NewCFBDecrypter(iv)
 	fd.XORKeyStream(tmp, ct)
-	if bytes.Compare(tmp, pt) != 0 {
+	if !bytes.Equal(tmp, pt) {
 		t.Fatal("decryption failed")
 	}
 }
@@ -65,7 +65,7 @@ func TestCFBRandom(t *testing.T) {
 		fd := c.NewCFBDecrypter(iv[:])
 		pt2 := make([]byte, len(ct))
 		fd.XORKeyStream(pt2, ct)
-		return bytes.Compare(pt2, pt) == 0
+		return bytes.Equal(pt2, pt)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost28147/ctr.go b/gost28147/ctr.go
index 1b646c1..6bb3dda 100644
--- a/gost28147/ctr.go
+++ b/gost28147/ctr.go
@@ -53,5 +53,4 @@ MainLoop:
 		}
 		i++
 	}
-	return
 }
diff --git a/gost28147/ctr_test.go b/gost28147/ctr_test.go
index 7eace06..086b450 100644
--- a/gost28147/ctr_test.go
+++ b/gost28147/ctr_test.go
@@ -104,12 +104,12 @@ func TestCTRGCL3Vector(t *testing.T) {
 	ctr := c.NewCTR(iv)
 	tmp := make([]byte, len(plaintext))
 	ctr.XORKeyStream(tmp, plaintext)
-	if bytes.Compare(tmp, ciphertext) != 0 {
+	if !bytes.Equal(tmp, ciphertext) {
 		t.Fatal("encryption failed")
 	}
 	ctr = c.NewCTR(iv)
 	ctr.XORKeyStream(tmp, tmp)
-	if bytes.Compare(tmp, plaintext) != 0 {
+	if !bytes.Equal(tmp, plaintext) {
 		t.Fatal("decryption failed")
 	}
 }
@@ -145,12 +145,12 @@ func TestCTRGCL2Vector(t *testing.T) {
 	ctr := c.NewCTR(iv[:])
 	tmp := make([]byte, len(plaintext))
 	ctr.XORKeyStream(tmp, plaintext)
-	if bytes.Compare(tmp, ciphertext) != 0 {
+	if !bytes.Equal(tmp, ciphertext) {
 		t.Fatal("encryption failed")
 	}
 	ctr = c.NewCTR(iv[:])
 	ctr.XORKeyStream(tmp, tmp)
-	if bytes.Compare(tmp, plaintext) != 0 {
+	if !bytes.Equal(tmp, plaintext) {
 		t.Fatal("decryption failed")
 	}
 }
@@ -166,7 +166,7 @@ func TestCTRRandom(t *testing.T) {
 		ctr.XORKeyStream(tmp, pt[:])
 		ctr = c.NewCTR(iv[:])
 		ctr.XORKeyStream(tmp, tmp)
-		return bytes.Compare(tmp, pt) == 0
+		return bytes.Equal(tmp, pt)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost28147/ecb_test.go b/gost28147/ecb_test.go
index 971fe61..fef8d39 100644
--- a/gost28147/ecb_test.go
+++ b/gost28147/ecb_test.go
@@ -100,12 +100,12 @@ func TestECBGCL3Vectors(t *testing.T) {
 	e := c.NewECBEncrypter()
 	tmp := make([]byte, len(plaintext))
 	e.CryptBlocks(tmp, plaintext)
-	if bytes.Compare(tmp, ciphertext) != 0 {
+	if !bytes.Equal(tmp, ciphertext) {
 		t.Fatal("encryption failed")
 	}
 	d := c.NewECBDecrypter()
 	d.CryptBlocks(tmp, tmp)
-	if bytes.Compare(tmp, plaintext) != 0 {
+	if !bytes.Equal(tmp, plaintext) {
 		t.Fatal("decryption failed")
 	}
 }
@@ -130,7 +130,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x07, 0xF9, 0x02, 0x7D, 0xF7, 0xF7, 0xDF, 0x89}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -146,7 +146,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x4F, 0xB5, 0x05, 0x36, 0xF9, 0x60, 0xA7, 0xB1}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -162,7 +162,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x67, 0x00, 0x34, 0xAC, 0x0F, 0xA8, 0x11, 0xB5}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -178,7 +178,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x81, 0x18, 0xFF, 0x9D, 0x3B, 0x3C, 0xFE, 0x7D}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -194,7 +194,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0xA0, 0x83, 0x82, 0x6A, 0x79, 0x0D, 0x3E, 0x0C}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -210,7 +210,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x4D, 0x1F, 0x2E, 0x6B, 0x0D, 0x9D, 0xE2, 0xCE}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -226,7 +226,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x2F, 0x3B, 0xB8, 0x48, 0x79, 0xD1, 0x1E, 0x52}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -242,7 +242,7 @@ func TestECBCryptoPPVectors(t *testing.T) {
 		ct = []byte{0x96, 0xF0, 0xA5, 0xC7, 0x7A, 0x04, 0xF5, 0xCE}
 		c = NewCipher(key, sbox)
 		c.Encrypt(tmp, pt)
-		if bytes.Compare(tmp, ct) != 0 {
+		if !bytes.Equal(tmp, ct) {
 			t.FailNow()
 		}
 	})
@@ -259,7 +259,7 @@ func TestECBCryptomanager(t *testing.T) {
 	c := NewCipher(key, &SboxIdGostR341194TestParamSet)
 	tmp := make([]byte, BlockSize)
 	c.Encrypt(tmp, []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88})
-	if bytes.Compare(tmp, []byte{0x03, 0x25, 0x1E, 0x14, 0xF9, 0xD2, 0x8A, 0xCB}) != 0 {
+	if !bytes.Equal(tmp, []byte{0x03, 0x25, 0x1E, 0x14, 0xF9, 0xD2, 0x8A, 0xCB}) {
 		t.FailNow()
 	}
 }
diff --git a/gost28147/mac_test.go b/gost28147/mac_test.go
index fa77f97..ab194d2 100644
--- a/gost28147/mac_test.go
+++ b/gost28147/mac_test.go
@@ -34,7 +34,7 @@ func TestMACVectors(t *testing.T) {
 
 	t.Run("a", func(t *testing.T) {
 		m.Write([]byte("a"))
-		if bytes.Compare(m.Sum(nil), []byte{0xbd, 0x5d, 0x3b, 0x5b, 0x2b, 0x7b, 0x57, 0xaf}) != 0 {
+		if !bytes.Equal(m.Sum(nil), []byte{0xbd, 0x5d, 0x3b, 0x5b, 0x2b, 0x7b, 0x57, 0xaf}) {
 			t.FailNow()
 		}
 	})
@@ -42,7 +42,7 @@ func TestMACVectors(t *testing.T) {
 	t.Run("abc", func(t *testing.T) {
 		m.Reset()
 		m.Write([]byte("abc"))
-		if bytes.Compare(m.Sum(nil), []byte{0x28, 0x66, 0x1e, 0x40, 0x80, 0x5b, 0x1f, 0xf9}) != 0 {
+		if !bytes.Equal(m.Sum(nil), []byte{0x28, 0x66, 0x1e, 0x40, 0x80, 0x5b, 0x1f, 0xf9}) {
 			t.FailNow()
 		}
 	})
@@ -52,7 +52,7 @@ func TestMACVectors(t *testing.T) {
 		for i := 0; i < 128; i++ {
 			m.Write([]byte("U"))
 		}
-		if bytes.Compare(m.Sum(nil), []byte{0x1a, 0x06, 0xd1, 0xba, 0xd7, 0x45, 0x80, 0xef}) != 0 {
+		if !bytes.Equal(m.Sum(nil), []byte{0x1a, 0x06, 0xd1, 0xba, 0xd7, 0x45, 0x80, 0xef}) {
 			t.FailNow()
 		}
 	})
@@ -62,7 +62,7 @@ func TestMACVectors(t *testing.T) {
 		for i := 0; i < 13; i++ {
 			m.Write([]byte("x"))
 		}
-		if bytes.Compare(m.Sum(nil), []byte{0x91, 0x7e, 0xe1, 0xf1, 0xa6, 0x68, 0xfb, 0xd3}) != 0 {
+		if !bytes.Equal(m.Sum(nil), []byte{0x91, 0x7e, 0xe1, 0xf1, 0xa6, 0x68, 0xfb, 0xd3}) {
 			t.FailNow()
 		}
 	})
@@ -93,7 +93,7 @@ func TestMACRandom(t *testing.T) {
 		m.Write(data)
 		m.Sum(tag2)
 
-		return bytes.Compare(tag1, tag2) == 0
+		return bytes.Equal(tag1, tag2)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost3410/2001_test.go b/gost3410/2001_test.go
index e98adfa..50712b4 100644
--- a/gost3410/2001_test.go
+++ b/gost3410/2001_test.go
@@ -67,10 +67,10 @@ func TestRFCVectors(t *testing.T) {
 	if err != nil {
 		t.FailNow()
 	}
-	if bytes.Compare(pub.Raw()[:32], pubX) != 0 {
+	if !bytes.Equal(pub.Raw()[:32], pubX) {
 		t.FailNow()
 	}
-	if bytes.Compare(pub.Raw()[32:], pubY) != 0 {
+	if !bytes.Equal(pub.Raw()[32:], pubY) {
 		t.FailNow()
 	}
 	ourSign, err := prv.SignDigest(digest, rand.Reader)
diff --git a/gost3410/2012_test.go b/gost3410/2012_test.go
index bc50f6f..28be7d8 100644
--- a/gost3410/2012_test.go
+++ b/gost3410/2012_test.go
@@ -65,7 +65,7 @@ func TestStdVector1(t *testing.T) {
 	if err != nil {
 		t.FailNow()
 	}
-	if bytes.Compare(sign, append(s, r...)) != 0 {
+	if !bytes.Equal(sign, append(s, r...)) {
 		t.FailNow()
 	}
 }
@@ -190,7 +190,7 @@ func TestStdVector2(t *testing.T) {
 	if err != nil {
 		t.FailNow()
 	}
-	if bytes.Compare(sign, append(s, r...)) != 0 {
+	if !bytes.Equal(sign, append(s, r...)) {
 		t.FailNow()
 	}
 }
@@ -336,10 +336,10 @@ func TestGCL3Vectors(t *testing.T) {
 	if err != nil {
 		t.FailNow()
 	}
-	if bytes.Compare(pub.Raw()[:64], pubX) != 0 {
+	if !bytes.Equal(pub.Raw()[:64], pubX) {
 		t.FailNow()
 	}
-	if bytes.Compare(pub.Raw()[64:], pubY) != 0 {
+	if !bytes.Equal(pub.Raw()[64:], pubY) {
 		t.FailNow()
 	}
 	ourSign, err := prv.SignDigest(digest, rand.Reader)
@@ -516,35 +516,41 @@ func TestSESPAKE(t *testing.T) {
 			t.FailNow()
 		}
 		raw, _ = hex.DecodeString(vector.xExpected)
-		if bytes.Compare(x.Bytes(), raw) != 0 {
+		if !bytes.Equal(x.Bytes(), raw) {
 			t.FailNow()
 		}
 		raw, _ = hex.DecodeString(vector.yExpected)
-		if bytes.Compare(y.Bytes(), raw) != 0 {
+		if !bytes.Equal(y.Bytes(), raw) {
 			t.FailNow()
 		}
 
 		raw, _ = hex.DecodeString(vector.alpha)
 		alpha := bytes2big(raw)
 		x, y, err = vector.curve.Exp(alpha, vector.curve.X, vector.curve.Y)
+		if err != nil {
+			t.FailNow()
+		}
 		raw, _ = hex.DecodeString(vector.xAlphaExpected)
-		if bytes.Compare(x.Bytes(), raw) != 0 {
+		if !bytes.Equal(x.Bytes(), raw) {
 			t.FailNow()
 		}
 		raw, _ = hex.DecodeString(vector.yAlphaExpected)
-		if bytes.Compare(y.Bytes(), raw) != 0 {
+		if !bytes.Equal(y.Bytes(), raw) {
 			t.FailNow()
 		}
 
 		raw, _ = hex.DecodeString(vector.beta)
 		beta := bytes2big(raw)
 		x, y, err = vector.curve.Exp(beta, vector.curve.X, vector.curve.Y)
+		if err != nil {
+			t.FailNow()
+		}
 		raw, _ = hex.DecodeString(vector.xBetaExpected)
-		if bytes.Compare(x.Bytes(), raw) != 0 {
+		if !bytes.Equal(x.Bytes(), raw) {
 			t.FailNow()
 		}
 		raw, _ = hex.DecodeString(vector.yBetaExpected)
-		if bytes.Compare(y.Bytes(), raw) != 0 {
+		if !bytes.Equal(y.Bytes(), raw) {
 			t.FailNow()
 		}
 	}
diff --git a/gost3410/vko2001_test.go b/gost3410/vko2001_test.go
index 912fc75..a6585f3 100644
--- a/gost3410/vko2001_test.go
+++ b/gost3410/vko2001_test.go
@@ -36,10 +36,10 @@ func TestVKO2001(t *testing.T) {
 	pub2, _ := prv2.PublicKey()
 	kek1, _ := prv1.KEK2001(pub2, ukm)
 	kek2, _ := prv2.KEK2001(pub1, ukm)
-	if bytes.Compare(kek1, kek2) != 0 {
+	if !bytes.Equal(kek1, kek2) {
 		t.FailNow()
 	}
-	if bytes.Compare(kek1, kek) != 0 {
+	if !bytes.Equal(kek1, kek) {
 		t.FailNow()
 	}
 }
@@ -80,7 +80,7 @@ func TestRandomVKO2001(t *testing.T) {
 		ukm := NewUKM(ukmRaw[:])
 		kek1, _ := prv1.KEK2001(pub2, ukm)
 		kek2, _ := prv2.KEK2001(pub1, ukm)
-		return bytes.Compare(kek1, kek2) == 0
+		return bytes.Equal(kek1, kek2)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost3410/vko2012_test.go b/gost3410/vko2012_test.go
index 0a63399..3fbfd9d 100644
--- a/gost3410/vko2012_test.go
+++ b/gost3410/vko2012_test.go
@@ -37,10 +37,10 @@ func TestVKO2012256(t *testing.T) {
 	prvB, _ := NewPrivateKey(c, prvRawB)
 	kekA, _ := prvA.KEK2012256(pubB, ukm)
 	kekB, _ := prvB.KEK2012256(pubA, ukm)
-	if bytes.Compare(kekA, kekB) != 0 {
+	if !bytes.Equal(kekA, kekB) {
 		t.FailNow()
 	}
-	if bytes.Compare(kekA, kek) != 0 {
+	if !bytes.Equal(kekA, kek) {
 		t.FailNow()
 	}
 }
@@ -61,7 +61,7 @@ func TestRandomVKO2012256(t *testing.T) {
 		ukm := NewUKM(ukmRaw[:])
 		kek1, _ := prv1.KEK2012256(pub2, ukm)
 		kek2, _ := prv2.KEK2012256(pub1, ukm)
-		return bytes.Compare(kek1, kek2) == 0
+		return bytes.Equal(kek1, kek2)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
@@ -83,10 +83,10 @@ func TestVKO2012512(t *testing.T) {
 	prvB, _ := NewPrivateKey(c, prvRawB)
 	kekA, _ := prvA.KEK2012512(pubB, ukm)
 	kekB, _ := prvB.KEK2012512(pubA, ukm)
-	if bytes.Compare(kekA, kekB) != 0 {
+	if !bytes.Equal(kekA, kekB) {
 		t.FailNow()
 	}
-	if bytes.Compare(kekA, kek) != 0 {
+	if !bytes.Equal(kekA, kek) {
 		t.FailNow()
 	}
 }
@@ -107,7 +107,7 @@ func TestRandomVKO2012512(t *testing.T) {
 		ukm := NewUKM(ukmRaw[:])
 		kek1, _ := prv1.KEK2012512(pub2, ukm)
 		kek2, _ := prv2.KEK2012512(pub1, ukm)
-		return bytes.Compare(kek1, kek2) == 0
+		return bytes.Equal(kek1, kek2)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost34112012256/esptree_test.go b/gost34112012256/esptree_test.go
index c9389ec..40e8589 100644
--- a/gost34112012256/esptree_test.go
+++ b/gost34112012256/esptree_test.go
@@ -30,12 +30,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x00}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x2F, 0xF1, 0xC9, 0x0E, 0xDE, 0x78, 0x6E, 0x06,
 			0x1E, 0x17, 0xB3, 0x74, 0xD7, 0x82, 0xAF, 0x7B,
 			0xD8, 0x80, 0xBD, 0x52, 0x7C, 0x66, 0xA2, 0xBA,
 			0xDC, 0x3E, 0x56, 0x9A, 0xAB, 0x27, 0x1D, 0xA4,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -51,12 +51,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x01, 0x00, 0x01}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x9A, 0xBA, 0xC6, 0x57, 0x78, 0x18, 0x0E, 0x6F,
 			0x2A, 0xF6, 0x1F, 0xB8, 0xD5, 0x71, 0x62, 0x36,
 			0x66, 0xC2, 0xF5, 0x13, 0x0D, 0x54, 0xE2, 0x11,
 			0x6C, 0x7D, 0x53, 0x0E, 0x6E, 0x7D, 0x48, 0xBC,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -72,12 +72,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x00}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x25, 0x65, 0x21, 0xE2, 0x70, 0xB7, 0x4A, 0x16,
 			0x4D, 0xFC, 0x26, 0xE6, 0xBF, 0x0C, 0xCA, 0x76,
 			0x5E, 0x9D, 0x41, 0x02, 0x7D, 0x4B, 0x7B, 0x19,
 			0x76, 0x2B, 0x1C, 0xC9, 0x01, 0xDC, 0xDE, 0x7F,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -93,12 +93,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x01, 0x00, 0x01}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x20, 0xE0, 0x46, 0xD4, 0x09, 0x83, 0x9B, 0x23,
 			0xF0, 0x66, 0xA5, 0x0A, 0x7A, 0x06, 0x5B, 0x4A,
 			0x39, 0x24, 0x4F, 0x0E, 0x29, 0xEF, 0x1E, 0x6F,
 			0x2E, 0x5D, 0x2E, 0x13, 0x55, 0xF5, 0xDA, 0x08,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -114,12 +114,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x00}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x98, 0xF1, 0x03, 0x01, 0x81, 0x0A, 0x04, 0x1C,
 			0xDA, 0xDD, 0xE1, 0xBD, 0x85, 0xA0, 0x8F, 0x21,
 			0x8B, 0xAC, 0xB5, 0x7E, 0x00, 0x35, 0xE2, 0x22,
 			0xC8, 0x31, 0xE3, 0xE4, 0xF0, 0xA2, 0x0C, 0x8F,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -135,12 +135,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x01}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x02, 0xC5, 0x41, 0x87, 0x7C, 0xC6, 0x23, 0xF3,
 			0xF1, 0x35, 0x91, 0x9A, 0x75, 0x13, 0xB6, 0xF8,
 			0xA8, 0xA1, 0x8C, 0xB2, 0x63, 0x99, 0x86, 0x2F,
 			0x50, 0x81, 0x4F, 0x52, 0x91, 0x01, 0x67, 0x84,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -156,12 +156,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x00}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x4C, 0x61, 0x45, 0x99, 0xA0, 0xA0, 0x67, 0xF1,
 			0x94, 0x87, 0x24, 0x0A, 0xE1, 0x00, 0xE1, 0xB7,
 			0xEA, 0xF2, 0x3E, 0xDA, 0xF8, 0x7E, 0x38, 0x73,
 			0x50, 0x86, 0x1C, 0x68, 0x3B, 0xA4, 0x04, 0x46,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
@@ -177,12 +177,12 @@ func TestESPTree(t *testing.T) {
 		})
 		is := []byte{0x00, 0x00, 0x00, 0x00, 0x01}
 		got := espTree.Derive(is)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0xB4, 0xF3, 0xF9, 0x0D, 0xC4, 0x87, 0xFA, 0xB8,
 			0xC4, 0xAF, 0xD0, 0xEB, 0x45, 0x49, 0xF2, 0xF0,
 			0xE4, 0x36, 0x32, 0xB6, 0x79, 0x19, 0x37, 0x2E,
 			0x1E, 0x96, 0x09, 0xEA, 0xF0, 0xB8, 0xE2, 0x28,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		if _, cached := espTree.DeriveCached(is); !cached {
diff --git a/gost34112012256/hkdf_test.go b/gost34112012256/hkdf_test.go
index f42fce8..ca4f012 100644
--- a/gost34112012256/hkdf_test.go
+++ b/gost34112012256/hkdf_test.go
@@ -34,12 +34,12 @@ func TestHKDF(t *testing.T) {
 			0x08, 0x09, 0x0a, 0x0b, 0x0c,
 		}
 		prk := hkdf.Extract(New, ikm, salt)
-		if bytes.Compare(prk, []byte{
+		if !bytes.Equal(prk, []byte{
 			0x94, 0x7d, 0x3d, 0x99, 0x2e, 0xdc, 0x44, 0xe3,
 			0x7b, 0x32, 0x72, 0x40, 0xf1, 0x5e, 0x62, 0x91,
 			0x3c, 0x0b, 0x91, 0xcc, 0x3e, 0x21, 0x43, 0xff,
 			0xe7, 0x72, 0x43, 0x6e, 0xc6, 0x3c, 0x99, 0xed,
-		}) != 0 {
+		}) {
 			t.Fatal("PRK differs")
 		}
 		info := []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9}
@@ -47,14 +47,14 @@ func TestHKDF(t *testing.T) {
 		if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
 			t.Fatal("HKDF-Expand failed")
 		}
-		if bytes.Compare(okm, []byte{
+		if !bytes.Equal(okm, []byte{
 			0x35, 0xf8, 0xf8, 0x03, 0x7a, 0xad, 0xf7, 0xaf,
 			0x3e, 0x4f, 0xc7, 0xbc, 0x8b, 0x93, 0xa9, 0x27,
 			0xd6, 0x85, 0xd4, 0x2f, 0x66, 0x28, 0xf9, 0xe6,
 			0x23, 0xc8, 0x5e, 0x19, 0x70, 0x09, 0x69, 0x2e,
 			0xae, 0xb1, 0x0b, 0x25, 0x26, 0x71, 0x2a, 0x7b,
 			0x49, 0xb7,
-		}) != 0 {
+		}) {
 			t.Fatal("OKM differs")
 		}
 	})
@@ -84,12 +84,12 @@ func TestHKDF(t *testing.T) {
 			0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 		}
 		prk := hkdf.Extract(New, ikm, salt)
-		if bytes.Compare(prk, []byte{
+		if !bytes.Equal(prk, []byte{
 			0xa2, 0xff, 0xcd, 0x64, 0x44, 0x45, 0xef, 0x94,
 			0x7e, 0x7e, 0xc9, 0xa8, 0x26, 0x89, 0x3d, 0x9a,
 			0x91, 0xfc, 0xe2, 0x65, 0xb0, 0xc2, 0xa9, 0x59,
 			0x6c, 0x59, 0xe1, 0x41, 0x53, 0x1d, 0x90, 0x77,
-		}) != 0 {
+		}) {
 			t.Fatal("PRK differs")
 		}
 		info := []byte{
@@ -108,7 +108,7 @@ func TestHKDF(t *testing.T) {
 		if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
 			t.Fatal("HKDF-Expand failed")
 		}
-		if bytes.Compare(okm, []byte{
+		if !bytes.Equal(okm, []byte{
 			0x28, 0x8c, 0x27, 0xff, 0xda, 0xf6, 0x4b, 0xe8,
 			0x24, 0xde, 0x84, 0x93, 0x48, 0x9d, 0x03, 0x12,
 			0x28, 0x07, 0xe9, 0x24, 0xaa, 0x6a, 0x09, 0x27,
@@ -120,7 +120,7 @@ func TestHKDF(t *testing.T) {
 			0xc0, 0xb8, 0x5c, 0x4c, 0x2b, 0x24, 0xb6, 0xd8,
 			0xb4, 0x38, 0x18, 0xa1, 0xa5, 0xb0, 0x67, 0x53,
 			0xaf, 0x72,
-		}) != 0 {
+		}) {
 			t.Fatal("OKM differs")
 		}
 	})
@@ -132,12 +132,12 @@ func TestHKDF(t *testing.T) {
 		}
 		salt := []byte{}
 		prk := hkdf.Extract(New, ikm, salt)
-		if bytes.Compare(prk, []byte{
+		if !bytes.Equal(prk, []byte{
 			0x1f, 0xfc, 0x6d, 0x2b, 0xf9, 0x59, 0x4d, 0xfd,
 			0xf7, 0x75, 0xc2, 0xc1, 0x8f, 0xa3, 0xae, 0xcc,
 			0x92, 0xb6, 0xf9, 0xbc, 0x5c, 0xff, 0x0e, 0x08,
 			0x6f, 0x34, 0x0f, 0xab, 0x33, 0x6d, 0x86, 0x5f,
-		}) != 0 {
+		}) {
 			t.Fatal("PRK differs")
 		}
 		info := []byte{}
@@ -145,14 +145,14 @@ func TestHKDF(t *testing.T) {
 		if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
 			t.Fatal("HKDF-Expand failed")
 		}
-		if bytes.Compare(okm, []byte{
+		if !bytes.Equal(okm, []byte{
 			0x6a, 0xad, 0xb1, 0xa6, 0x48, 0x96, 0x2f, 0x0d,
 			0x96, 0x19, 0xcc, 0xdb, 0xf9, 0xd9, 0x2d, 0xc3,
 			0x54, 0x79, 0x73, 0x73, 0x3b, 0xc4, 0x06, 0x1d,
 			0x9f, 0xa5, 0x3e, 0xa8, 0x2a, 0x17, 0x35, 0xd7,
 			0xf3, 0xa4, 0x84, 0x6c, 0x76, 0xf9, 0x94, 0xb5,
 			0xdd, 0x03,
-		}) != 0 {
+		}) {
 			t.Fatal("OKM differs")
 		}
 	})
diff --git a/gost34112012256/kdf_test.go b/gost34112012256/kdf_test.go
index 5c85f73..e30d758 100644
--- a/gost34112012256/kdf_test.go
+++ b/gost34112012256/kdf_test.go
@@ -32,12 +32,12 @@ func TestKDFGOSTR34112012256(t *testing.T) {
 		[]byte{0x26, 0xbd, 0xb8, 0x78},
 		[]byte{0xaf, 0x21, 0x43, 0x41, 0x45, 0x65, 0x63, 0x78},
 	)
-	if bytes.Compare(derived, []byte{
+	if !bytes.Equal(derived, []byte{
 		0xa1, 0xaa, 0x5f, 0x7d, 0xe4, 0x02, 0xd7, 0xb3,
 		0xd3, 0x23, 0xf2, 0x99, 0x1c, 0x8d, 0x45, 0x34,
 		0x01, 0x31, 0x37, 0x01, 0x0a, 0x83, 0x75, 0x4f,
 		0xd0, 0xaf, 0x6d, 0x7c, 0xd4, 0x92, 0x2e, 0xd9,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
diff --git a/gost34112012256/tlstree_test.go b/gost34112012256/tlstree_test.go
index 6fe981b..64c47af 100644
--- a/gost34112012256/tlstree_test.go
+++ b/gost34112012256/tlstree_test.go
@@ -29,75 +29,75 @@ func TestTLSTreeMagmaCTROMAC(t *testing.T) {
 	})
 	t.Run("0", func(t *testing.T) {
 		got := tt.Derive(0)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 			0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 			0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 			0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
-		if bytes.Compare(got, tt.Derive(1)) != 0 {
+		if !bytes.Equal(got, tt.Derive(1)) {
 			t.FailNow()
 		}
 	})
 	t.Run("4095", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(4095), []byte{
+		if !bytes.Equal(tt.Derive(4095), []byte{
 			0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 			0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 			0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 			0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("4096", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(4096), []byte{
+		if !bytes.Equal(tt.Derive(4096), []byte{
 			0x71, 0x86, 0x93, 0xEC, 0xD3, 0xF1, 0xDC, 0xE2,
 			0x11, 0x93, 0xBD, 0x56, 0x40, 0x6A, 0xA4, 0xE2,
 			0x09, 0x0F, 0xE1, 0xC8, 0x7A, 0x5D, 0x5D, 0x7A,
 			0x8C, 0xE6, 0xE0, 0xD8, 0x28, 0xA4, 0x39, 0x15,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("33554431", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(33554431), []byte{
+		if !bytes.Equal(tt.Derive(33554431), []byte{
 			0xCD, 0x4E, 0x6F, 0x09, 0x94, 0xC4, 0xCA, 0x17,
 			0xA9, 0xAD, 0xE5, 0x3D, 0x69, 0x20, 0x49, 0x77,
 			0x57, 0x87, 0x3B, 0xC0, 0x8D, 0x4F, 0x98, 0x06,
 			0xE3, 0xC9, 0x99, 0xA7, 0xE4, 0xAE, 0x70, 0xE0,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("33554432", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(33554432), []byte{
+		if !bytes.Equal(tt.Derive(33554432), []byte{
 			0x4E, 0xAB, 0x0F, 0x8A, 0x28, 0x2D, 0xE5, 0x78,
 			0x85, 0x7B, 0xE0, 0x15, 0xD1, 0x32, 0xCD, 0xFD,
 			0x88, 0xF0, 0xEB, 0xD9, 0x9D, 0x10, 0xCC, 0xA3,
 			0xB6, 0xD9, 0x11, 0x4E, 0x37, 0x56, 0x5D, 0xE7,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("274877906943", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(274877906943), []byte{
+		if !bytes.Equal(tt.Derive(274877906943), []byte{
 			0x37, 0x06, 0xB1, 0xBE, 0xE6, 0xF3, 0xBE, 0xDB,
 			0x74, 0x66, 0x4E, 0x1C, 0x43, 0x40, 0xB5, 0xE1,
 			0x81, 0x5F, 0xFA, 0x87, 0xEA, 0x80, 0xF4, 0x0E,
 			0xAF, 0xCC, 0x28, 0xEF, 0x30, 0xDD, 0xF3, 0xBB,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("274877906944", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(274877906944), []byte{
+		if !bytes.Equal(tt.Derive(274877906944), []byte{
 			0x9B, 0xE5, 0x7C, 0xB5, 0x2F, 0x46, 0xB6, 0x0C,
 			0x68, 0x40, 0xCD, 0x4E, 0x95, 0x9A, 0x16, 0x8A,
 			0x74, 0x82, 0x2C, 0x1D, 0x00, 0x6A, 0xC7, 0x46,
 			0xDA, 0xBB, 0xB9, 0x84, 0x8E, 0xB0, 0xA5, 0x8A,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -112,75 +112,75 @@ func TestTLSTreeKuznyechikCTROMAC(t *testing.T) {
 	})
 	t.Run("0", func(t *testing.T) {
 		got := tt.Derive(0)
-		if bytes.Compare(got, []byte{
+		if !bytes.Equal(got, []byte{
 			0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 			0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 			0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 			0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
-		if bytes.Compare(got, tt.Derive(1)) != 0 {
+		if !bytes.Equal(got, tt.Derive(1)) {
 			t.FailNow()
 		}
 	})
 	t.Run("63", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(63), []byte{
+		if !bytes.Equal(tt.Derive(63), []byte{
 			0x50, 0x76, 0x42, 0xD9, 0x58, 0xC5, 0x20, 0xC6,
 			0xD7, 0xEE, 0xF5, 0xCA, 0x8A, 0x53, 0x16, 0xD4,
 			0xF3, 0x4B, 0x85, 0x5D, 0x2D, 0xD4, 0xBC, 0xBF,
 			0x4E, 0x5B, 0xF0, 0xFF, 0x64, 0x1A, 0x19, 0xFF,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("64", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(64), []byte{
+		if !bytes.Equal(tt.Derive(64), []byte{
 			0xC1, 0x9B, 0x63, 0x9F, 0x4B, 0xEA, 0x78, 0x8C,
 			0x1C, 0x59, 0xB4, 0xC8, 0x87, 0xDB, 0x5B, 0x07,
 			0xC1, 0x91, 0x19, 0x10, 0x18, 0x68, 0xDA, 0xB8,
 			0x9A, 0x8D, 0x93, 0x61, 0xB2, 0xF0, 0x10, 0xF3,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("524287", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(524287), []byte{
+		if !bytes.Equal(tt.Derive(524287), []byte{
 			0x92, 0x30, 0x3E, 0xB5, 0x61, 0x56, 0x88, 0x54,
 			0xE3, 0x3E, 0x4F, 0xE0, 0x97, 0xA9, 0x95, 0x99,
 			0x17, 0x9F, 0x5B, 0x90, 0x94, 0xAE, 0x34, 0x79,
 			0xE6, 0x1C, 0x43, 0x69, 0x3A, 0x3F, 0x0A, 0x06,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("524288", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(524288), []byte{
+		if !bytes.Equal(tt.Derive(524288), []byte{
 			0xE8, 0x55, 0xA0, 0xE2, 0xCB, 0xDD, 0x68, 0xC1,
 			0x13, 0x7C, 0xEF, 0x3E, 0x80, 0x1E, 0x0B, 0xFF,
 			0x68, 0x62, 0x8C, 0x36, 0x43, 0x68, 0x27, 0x6D,
 			0x0C, 0xB8, 0x7E, 0xB5, 0x6E, 0x94, 0xEF, 0x42,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("4294967295", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(4294967295), []byte{
+		if !bytes.Equal(tt.Derive(4294967295), []byte{
 			0x93, 0xD3, 0xCA, 0xE9, 0x5A, 0x55, 0xB7, 0x1A,
 			0xA3, 0xB9, 0xA7, 0xDD, 0xF9, 0x9A, 0x6A, 0xAC,
 			0x3F, 0xDA, 0x17, 0x2A, 0x79, 0x60, 0x58, 0x04,
 			0xA9, 0xC9, 0xFC, 0x6E, 0x84, 0x8A, 0xF1, 0xAA,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 	t.Run("4294967296", func(t *testing.T) {
-		if bytes.Compare(tt.Derive(4294967296), []byte{
+		if !bytes.Equal(tt.Derive(4294967296), []byte{
 			0x7F, 0xFB, 0x1A, 0xD7, 0xE5, 0x7B, 0x70, 0xBE,
 			0x10, 0x96, 0x31, 0xD2, 0x71, 0x92, 0x98, 0xB9,
 			0x7D, 0xEE, 0x3B, 0x00, 0x8D, 0x86, 0xF8, 0x3D,
 			0xAA, 0xF6, 0x2A, 0x4E, 0xA5, 0xB7, 0xAA, 0xFD,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
diff --git a/gost341194/hash.go b/gost341194/hash.go
index 6d1a49b..0c3ae1a 100644
--- a/gost341194/hash.go
+++ b/gost341194/hash.go
@@ -131,7 +131,6 @@ func blockXor(dst, a, b *[BlockSize]byte) {
 	for i := 0; i < BlockSize; i++ {
 		dst[i] = a[i] ^ b[i]
 	}
-	return
 }
 
 func (h *Hash) step(hin, m [BlockSize]byte) [BlockSize]byte {
diff --git a/gost341194/hash_test.go b/gost341194/hash_test.go
index ea825c2..357a2b5 100644
--- a/gost341194/hash_test.go
+++ b/gost341194/hash_test.go
@@ -34,12 +34,12 @@ func TestVectors(t *testing.T) {
 	h := New(SboxDefault)
 
 	t.Run("empty", func(t *testing.T) {
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xce, 0x85, 0xb9, 0x9c, 0xc4, 0x67, 0x52, 0xff,
 			0xfe, 0xe3, 0x5c, 0xab, 0x9a, 0x7b, 0x02, 0x78,
 			0xab, 0xb4, 0xc2, 0xd2, 0x05, 0x5c, 0xff, 0x68,
 			0x5a, 0xf4, 0x91, 0x2c, 0x49, 0x49, 0x0f, 0x8d,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -47,12 +47,12 @@ func TestVectors(t *testing.T) {
 	t.Run("a", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("a"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xd4, 0x2c, 0x53, 0x9e, 0x36, 0x7c, 0x66, 0xe9,
 			0xc8, 0x8a, 0x80, 0x1f, 0x66, 0x49, 0x34, 0x9c,
 			0x21, 0x87, 0x1b, 0x43, 0x44, 0xc6, 0xa5, 0x73,
 			0xf8, 0x49, 0xfd, 0xce, 0x62, 0xf3, 0x14, 0xdd,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -60,12 +60,12 @@ func TestVectors(t *testing.T) {
 	t.Run("abc", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("abc"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xf3, 0x13, 0x43, 0x48, 0xc4, 0x4f, 0xb1, 0xb2,
 			0xa2, 0x77, 0x72, 0x9e, 0x22, 0x85, 0xeb, 0xb5,
 			0xcb, 0x5e, 0x0f, 0x29, 0xc9, 0x75, 0xbc, 0x75,
 			0x3b, 0x70, 0x49, 0x7c, 0x06, 0xa4, 0xd5, 0x1d,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -73,12 +73,12 @@ func TestVectors(t *testing.T) {
 	t.Run("message digest", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("message digest"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xad, 0x44, 0x34, 0xec, 0xb1, 0x8f, 0x2c, 0x99,
 			0xb6, 0x0c, 0xbe, 0x59, 0xec, 0x3d, 0x24, 0x69,
 			0x58, 0x2b, 0x65, 0x27, 0x3f, 0x48, 0xde, 0x72,
 			0xdb, 0x2f, 0xde, 0x16, 0xa4, 0x88, 0x9a, 0x4d,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -88,12 +88,12 @@ func TestVectors(t *testing.T) {
 		for i := 0; i < 128; i++ {
 			h.Write([]byte("U"))
 		}
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x53, 0xa3, 0xa3, 0xed, 0x25, 0x18, 0x0c, 0xef,
 			0x0c, 0x1d, 0x85, 0xa0, 0x74, 0x27, 0x3e, 0x55,
 			0x1c, 0x25, 0x66, 0x0a, 0x87, 0x06, 0x2a, 0x52,
 			0xd9, 0x26, 0xa9, 0xe8, 0xfe, 0x57, 0x33, 0xa4,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -101,12 +101,12 @@ func TestVectors(t *testing.T) {
 	t.Run("lazy dog", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("The quick brown fox jumps over the lazy dog"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x77, 0xb7, 0xfa, 0x41, 0x0c, 0x9a, 0xc5, 0x8a,
 			0x25, 0xf4, 0x9b, 0xca, 0x7d, 0x04, 0x68, 0xc9,
 			0x29, 0x65, 0x29, 0x31, 0x5e, 0xac, 0xa7, 0x6b,
 			0xd1, 0xa1, 0x0f, 0x37, 0x6d, 0x1f, 0x42, 0x94,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -114,12 +114,12 @@ func TestVectors(t *testing.T) {
 	t.Run("lazy cog", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("The quick brown fox jumps over the lazy cog"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xa3, 0xeb, 0xc4, 0xda, 0xaa, 0xb7, 0x8b, 0x0b,
 			0xe1, 0x31, 0xda, 0xb5, 0x73, 0x7a, 0x7f, 0x67,
 			0xe6, 0x02, 0x67, 0x0d, 0x54, 0x35, 0x21, 0x31,
 			0x91, 0x50, 0xd2, 0xe1, 0x4e, 0xee, 0xc4, 0x45,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -127,12 +127,12 @@ func TestVectors(t *testing.T) {
 	t.Run("32", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("This is message, length=32 bytes"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xb1, 0xc4, 0x66, 0xd3, 0x75, 0x19, 0xb8, 0x2e,
 			0x83, 0x19, 0x81, 0x9f, 0xf3, 0x25, 0x95, 0xe0,
 			0x47, 0xa2, 0x8c, 0xb6, 0xf8, 0x3e, 0xff, 0x1c,
 			0x69, 0x16, 0xa8, 0x15, 0xa6, 0x37, 0xff, 0xfa,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -140,12 +140,12 @@ func TestVectors(t *testing.T) {
 	t.Run("50", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("Suppose the original message has length = 50 bytes"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x47, 0x1a, 0xba, 0x57, 0xa6, 0x0a, 0x77, 0x0d,
 			0x3a, 0x76, 0x13, 0x06, 0x35, 0xc1, 0xfb, 0xea,
 			0x4e, 0xf1, 0x4d, 0xe5, 0x1f, 0x78, 0xb4, 0xae,
 			0x57, 0xdd, 0x89, 0x3b, 0x62, 0xf5, 0x52, 0x08,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -155,12 +155,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	h := New(&gost28147.SboxIdGostR341194CryptoProParamSet)
 
 	t.Run("empty", func(t *testing.T) {
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x98, 0x1e, 0x5f, 0x3c, 0xa3, 0x0c, 0x84, 0x14,
 			0x87, 0x83, 0x0f, 0x84, 0xfb, 0x43, 0x3e, 0x13,
 			0xac, 0x11, 0x01, 0x56, 0x9b, 0x9c, 0x13, 0x58,
 			0x4a, 0xc4, 0x83, 0x23, 0x4c, 0xd6, 0x56, 0xc0,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -168,12 +168,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("a", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("a"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xe7, 0x4c, 0x52, 0xdd, 0x28, 0x21, 0x83, 0xbf,
 			0x37, 0xaf, 0x00, 0x79, 0xc9, 0xf7, 0x80, 0x55,
 			0x71, 0x5a, 0x10, 0x3f, 0x17, 0xe3, 0x13, 0x3c,
 			0xef, 0xf1, 0xaa, 0xcf, 0x2f, 0x40, 0x30, 0x11,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -181,12 +181,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("abc", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("abc"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xb2, 0x85, 0x05, 0x6d, 0xbf, 0x18, 0xd7, 0x39,
 			0x2d, 0x76, 0x77, 0x36, 0x95, 0x24, 0xdd, 0x14,
 			0x74, 0x74, 0x59, 0xed, 0x81, 0x43, 0x99, 0x7e,
 			0x16, 0x3b, 0x29, 0x86, 0xf9, 0x2f, 0xd4, 0x2c,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -194,12 +194,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("message digest", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("message digest"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xbc, 0x60, 0x41, 0xdd, 0x2a, 0xa4, 0x01, 0xeb,
 			0xfa, 0x6e, 0x98, 0x86, 0x73, 0x41, 0x74, 0xfe,
 			0xbd, 0xb4, 0x72, 0x9a, 0xa9, 0x72, 0xd6, 0x0f,
 			0x54, 0x9a, 0xc3, 0x9b, 0x29, 0x72, 0x1b, 0xa0,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -207,12 +207,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("lazy dog", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("The quick brown fox jumps over the lazy dog"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x90, 0x04, 0x29, 0x4a, 0x36, 0x1a, 0x50, 0x8c,
 			0x58, 0x6f, 0xe5, 0x3d, 0x1f, 0x1b, 0x02, 0x74,
 			0x67, 0x65, 0xe7, 0x1b, 0x76, 0x54, 0x72, 0x78,
 			0x6e, 0x47, 0x70, 0xd5, 0x65, 0x83, 0x0a, 0x76,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -220,12 +220,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("32", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("This is message, length=32 bytes"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x2c, 0xef, 0xc2, 0xf7, 0xb7, 0xbd, 0xc5, 0x14,
 			0xe1, 0x8e, 0xa5, 0x7f, 0xa7, 0x4f, 0xf3, 0x57,
 			0xe7, 0xfa, 0x17, 0xd6, 0x52, 0xc7, 0x5f, 0x69,
 			0xcb, 0x1b, 0xe7, 0x89, 0x3e, 0xde, 0x48, 0xeb,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -233,12 +233,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 	t.Run("50", func(t *testing.T) {
 		h.Reset()
 		h.Write([]byte("Suppose the original message has length = 50 bytes"))
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xc3, 0x73, 0x0c, 0x5c, 0xbc, 0xca, 0xcf, 0x91,
 			0x5a, 0xc2, 0x92, 0x67, 0x6f, 0x21, 0xe8, 0xbd,
 			0x4e, 0xf7, 0x53, 0x31, 0xd9, 0x40, 0x5e, 0x5f,
 			0x1a, 0x61, 0xdc, 0x31, 0x30, 0xa6, 0x50, 0x11,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -248,12 +248,12 @@ func TestVectorsCryptoPro(t *testing.T) {
 		for i := 0; i < 128; i++ {
 			h.Write([]byte{'U'})
 		}
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0x1c, 0x4a, 0xc7, 0x61, 0x46, 0x91, 0xbb, 0xf4,
 			0x27, 0xfa, 0x23, 0x16, 0x21, 0x6b, 0xe8, 0xf1,
 			0x0d, 0x92, 0xed, 0xfd, 0x37, 0xcd, 0x10, 0x27,
 			0x51, 0x4c, 0x10, 0x08, 0xf6, 0x49, 0xc4, 0xe8,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -270,7 +270,7 @@ func TestRandom(t *testing.T) {
 			h.Write([]byte{c})
 		}
 		d2 := h.Sum(nil)
-		return bytes.Compare(d1, d2) == 0
+		return bytes.Equal(d1, d2)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/gost341194/pbkdf2_test.go b/gost341194/pbkdf2_test.go
index 5279d7c..e8ad196 100644
--- a/gost341194/pbkdf2_test.go
+++ b/gost341194/pbkdf2_test.go
@@ -32,7 +32,7 @@ func PBKDF2Hash() hash.Hash {
 // http://tc26.ru/methods/containers_v1/Addition_to_PKCS5_v1_0.pdf test vectors
 func TestPBKDF2Vectors(t *testing.T) {
 	t.Run("1", func(t *testing.T) {
-		if bytes.Compare(pbkdf2.Key(
+		if !bytes.Equal(pbkdf2.Key(
 			[]byte("password"),
 			[]byte("salt"),
 			1,
@@ -43,13 +43,13 @@ func TestPBKDF2Vectors(t *testing.T) {
 			0xc5, 0x43, 0x67, 0x42, 0x53, 0xf6, 0x8b, 0xd0,
 			0xb7, 0x34, 0x45, 0xd0, 0x7f, 0x24, 0x1b, 0xed,
 			0x87, 0x28, 0x82, 0xda, 0x21, 0x66, 0x2d, 0x58,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 
 	t.Run("2", func(t *testing.T) {
-		if bytes.Compare(pbkdf2.Key(
+		if !bytes.Equal(pbkdf2.Key(
 			[]byte("password"),
 			[]byte("salt"),
 			2,
@@ -60,13 +60,13 @@ func TestPBKDF2Vectors(t *testing.T) {
 			0xa4, 0x8b, 0x07, 0xb7, 0x92, 0x77, 0x5d, 0xf7,
 			0x9f, 0x2d, 0xb3, 0x4f, 0xef, 0x25, 0xf2, 0x74,
 			0x37, 0x88, 0x72, 0xfe, 0xd7, 0xed, 0x1b, 0xb3,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 
 	t.Run("4096", func(t *testing.T) {
-		if bytes.Compare(pbkdf2.Key(
+		if !bytes.Equal(pbkdf2.Key(
 			[]byte("password"),
 			[]byte("salt"),
 			4096,
@@ -77,14 +77,14 @@ func TestPBKDF2Vectors(t *testing.T) {
 			0x10, 0xd0, 0xae, 0xb3, 0x6a, 0xf4, 0x98, 0xe7,
 			0xa9, 0x74, 0x67, 0xf3, 0xb3, 0x11, 0x16, 0xa5,
 			0xa7, 0xc1, 0xaf, 0xff, 0x9d, 0xea, 0xda, 0xfe,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 
 	/*
 		t.Run("16777216", func(t *testing.T) {
-			if bytes.Compare(pbkdf2.Key(
+			if !bytes.Equal(pbkdf2.Key(
 				[]byte("password"),
 				[]byte("salt"),
 				16777216,
@@ -95,14 +95,14 @@ func TestPBKDF2Vectors(t *testing.T) {
 				0x20, 0x85, 0x0c, 0x5c, 0x09, 0xde, 0x0a, 0x52,
 				0x51, 0x00, 0x93, 0x8a, 0x59, 0xb1, 0xb5, 0xc3,
 				0xf7, 0x81, 0x09, 0x10, 0xd0, 0x5f, 0xcd, 0x97,
-			}) != 0 {
+			}) {
 				t.FailNow()
 			}
 		})
 	*/
 
 	t.Run("many", func(t *testing.T) {
-		if bytes.Compare(pbkdf2.Key(
+		if !bytes.Equal(pbkdf2.Key(
 			[]byte("passwordPASSWORDpassword"),
 			[]byte("saltSALTsaltSALTsaltSALTsaltSALTsalt"),
 			4096,
@@ -114,13 +114,13 @@ func TestPBKDF2Vectors(t *testing.T) {
 			0x26, 0x5a, 0x79, 0x2a, 0x35, 0xbe, 0xcd, 0xe8,
 			0xd5, 0x6f, 0x32, 0x6b, 0x49, 0xc8, 0x50, 0x47,
 			0xb7, 0x63, 0x8a, 0xcb, 0x47, 0x64, 0xb1, 0xfd,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
 
 	t.Run("zero byte", func(t *testing.T) {
-		if bytes.Compare(pbkdf2.Key(
+		if !bytes.Equal(pbkdf2.Key(
 			[]byte("pass\x00word"),
 			[]byte("sa\x00lt"),
 			4096,
@@ -130,7 +130,7 @@ func TestPBKDF2Vectors(t *testing.T) {
 			0x43, 0xe0, 0x6c, 0x55, 0x90, 0xb0, 0x8c, 0x02,
 			0x25, 0x24, 0x23, 0x73, 0x12, 0x7e, 0xdf, 0x9c,
 			0x8e, 0x9c, 0x32, 0x91,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
diff --git a/gost3412128/cipher_test.go b/gost3412128/cipher_test.go
index 45bd673..52c60bc 100644
--- a/gost3412128/cipher_test.go
+++ b/gost3412128/cipher_test.go
@@ -52,7 +52,7 @@ func TestRandom(t *testing.T) {
 		c := NewCipher(key[:])
 		c.Encrypt(data, pt[:])
 		c.Decrypt(data, data)
-		return bytes.Compare(data, pt[:]) == 0
+		return bytes.Equal(data, pt[:])
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
@@ -87,31 +87,31 @@ func TestS(t *testing.T) {
 		0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x00,
 	}
 	s(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0xb6, 0x6c, 0xd8, 0x88, 0x7d, 0x38, 0xe8, 0xd7,
 		0x77, 0x65, 0xae, 0xea, 0x0c, 0x9a, 0x7e, 0xfc,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	s(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x55, 0x9d, 0x8d, 0xd7, 0xbd, 0x06, 0xcb, 0xfe,
 		0x7e, 0x7b, 0x26, 0x25, 0x23, 0x28, 0x0d, 0x39,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	s(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x0c, 0x33, 0x22, 0xfe, 0xd5, 0x31, 0xe4, 0x63,
 		0x0d, 0x80, 0xef, 0x5c, 0x5a, 0x81, 0xc5, 0x0b,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	s(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x23, 0xae, 0x65, 0x63, 0x3f, 0x84, 0x2d, 0x29,
 		0xc5, 0xdf, 0x52, 0x9c, 0x13, 0xf5, 0xac, 0xda,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
@@ -131,31 +131,31 @@ func TestR(t *testing.T) {
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
 	}
 	R(blk[:])
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	R(blk[:])
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	R(blk[:])
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x64, 0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	R(blk[:])
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x0d, 0x64, 0xa5, 0x94, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
@@ -166,146 +166,146 @@ func TestL(t *testing.T) {
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	}
 	l(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0xd4, 0x56, 0x58, 0x4d, 0xd0, 0xe3, 0xe8, 0x4c,
 		0xc3, 0x16, 0x6e, 0x4b, 0x7f, 0xa2, 0x89, 0x0d,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	l(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x79, 0xd2, 0x62, 0x21, 0xb8, 0x7b, 0x58, 0x4c,
 		0xd4, 0x2f, 0xbc, 0x4f, 0xfe, 0xa5, 0xde, 0x9a,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	l(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0x0e, 0x93, 0x69, 0x1a, 0x0c, 0xfc, 0x60, 0x40,
 		0x8b, 0x7b, 0x68, 0xf6, 0x6b, 0x51, 0x3c, 0x13,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	l(&blk)
-	if bytes.Compare(blk[:], []byte{
+	if !bytes.Equal(blk[:], []byte{
 		0xe6, 0xa8, 0x09, 0x4f, 0xee, 0x0a, 0xa2, 0x04,
 		0xfd, 0x97, 0xbc, 0xb0, 0xb4, 0x4b, 0x85, 0x80,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
 
 func TestC(t *testing.T) {
-	if bytes.Compare(cBlk[0][:], []byte{
+	if !bytes.Equal(cBlk[0][:], []byte{
 		0x6e, 0xa2, 0x76, 0x72, 0x6c, 0x48, 0x7a, 0xb8,
 		0x5d, 0x27, 0xbd, 0x10, 0xdd, 0x84, 0x94, 0x01,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[1][:], []byte{
+	if !bytes.Equal(cBlk[1][:], []byte{
 		0xdc, 0x87, 0xec, 0xe4, 0xd8, 0x90, 0xf4, 0xb3,
 		0xba, 0x4e, 0xb9, 0x20, 0x79, 0xcb, 0xeb, 0x02,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[2][:], []byte{
+	if !bytes.Equal(cBlk[2][:], []byte{
 		0xb2, 0x25, 0x9a, 0x96, 0xb4, 0xd8, 0x8e, 0x0b,
 		0xe7, 0x69, 0x04, 0x30, 0xa4, 0x4f, 0x7f, 0x03,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[3][:], []byte{
+	if !bytes.Equal(cBlk[3][:], []byte{
 		0x7b, 0xcd, 0x1b, 0x0b, 0x73, 0xe3, 0x2b, 0xa5,
 		0xb7, 0x9c, 0xb1, 0x40, 0xf2, 0x55, 0x15, 0x04,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[4][:], []byte{
+	if !bytes.Equal(cBlk[4][:], []byte{
 		0x15, 0x6f, 0x6d, 0x79, 0x1f, 0xab, 0x51, 0x1d,
 		0xea, 0xbb, 0x0c, 0x50, 0x2f, 0xd1, 0x81, 0x05,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[5][:], []byte{
+	if !bytes.Equal(cBlk[5][:], []byte{
 		0xa7, 0x4a, 0xf7, 0xef, 0xab, 0x73, 0xdf, 0x16,
 		0x0d, 0xd2, 0x08, 0x60, 0x8b, 0x9e, 0xfe, 0x06,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[6][:], []byte{
+	if !bytes.Equal(cBlk[6][:], []byte{
 		0xc9, 0xe8, 0x81, 0x9d, 0xc7, 0x3b, 0xa5, 0xae,
 		0x50, 0xf5, 0xb5, 0x70, 0x56, 0x1a, 0x6a, 0x07,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(cBlk[7][:], []byte{
+	if !bytes.Equal(cBlk[7][:], []byte{
 		0xf6, 0x59, 0x36, 0x16, 0xe6, 0x05, 0x56, 0x89,
 		0xad, 0xfb, 0xa1, 0x80, 0x27, 0xaa, 0x2a, 0x08,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
 
 func TestRoundKeys(t *testing.T) {
 	c := NewCipher(key)
-	if bytes.Compare(c.ks[0][:], []byte{
+	if !bytes.Equal(c.ks[0][:], []byte{
 		0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
 		0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[1][:], []byte{
+	if !bytes.Equal(c.ks[1][:], []byte{
 		0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
 		0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[2][:], []byte{
+	if !bytes.Equal(c.ks[2][:], []byte{
 		0xdb, 0x31, 0x48, 0x53, 0x15, 0x69, 0x43, 0x43,
 		0x22, 0x8d, 0x6a, 0xef, 0x8c, 0xc7, 0x8c, 0x44,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[3][:], []byte{
+	if !bytes.Equal(c.ks[3][:], []byte{
 		0x3d, 0x45, 0x53, 0xd8, 0xe9, 0xcf, 0xec, 0x68,
 		0x15, 0xeb, 0xad, 0xc4, 0x0a, 0x9f, 0xfd, 0x04,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[4][:], []byte{
+	if !bytes.Equal(c.ks[4][:], []byte{
 		0x57, 0x64, 0x64, 0x68, 0xc4, 0x4a, 0x5e, 0x28,
 		0xd3, 0xe5, 0x92, 0x46, 0xf4, 0x29, 0xf1, 0xac,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[5][:], []byte{
+	if !bytes.Equal(c.ks[5][:], []byte{
 		0xbd, 0x07, 0x94, 0x35, 0x16, 0x5c, 0x64, 0x32,
 		0xb5, 0x32, 0xe8, 0x28, 0x34, 0xda, 0x58, 0x1b,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[6][:], []byte{
+	if !bytes.Equal(c.ks[6][:], []byte{
 		0x51, 0xe6, 0x40, 0x75, 0x7e, 0x87, 0x45, 0xde,
 		0x70, 0x57, 0x27, 0x26, 0x5a, 0x00, 0x98, 0xb1,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[7][:], []byte{
+	if !bytes.Equal(c.ks[7][:], []byte{
 		0x5a, 0x79, 0x25, 0x01, 0x7b, 0x9f, 0xdd, 0x3e,
 		0xd7, 0x2a, 0x91, 0xa2, 0x22, 0x86, 0xf9, 0x84,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[8][:], []byte{
+	if !bytes.Equal(c.ks[8][:], []byte{
 		0xbb, 0x44, 0xe2, 0x53, 0x78, 0xc7, 0x31, 0x23,
 		0xa5, 0xf3, 0x2f, 0x73, 0xcd, 0xb6, 0xe5, 0x17,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(c.ks[9][:], []byte{
+	if !bytes.Equal(c.ks[9][:], []byte{
 		0x72, 0xe9, 0xdd, 0x74, 0x16, 0xbc, 0xf4, 0x5b,
 		0x75, 0x5d, 0xba, 0xa8, 0x8e, 0x4a, 0x40, 0x43,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
@@ -314,7 +314,7 @@ func TestVectorEncrypt(t *testing.T) {
 	c := NewCipher(key)
 	dst := make([]byte, BlockSize)
 	c.Encrypt(dst, pt[:])
-	if bytes.Compare(dst, ct[:]) != 0 {
+	if !bytes.Equal(dst, ct[:]) {
 		t.FailNow()
 	}
 }
@@ -323,7 +323,7 @@ func TestVectorDecrypt(t *testing.T) {
 	c := NewCipher(key)
 	dst := make([]byte, BlockSize)
 	c.Decrypt(dst, ct[:])
-	if bytes.Compare(dst, pt[:]) != 0 {
+	if !bytes.Equal(dst, pt[:]) {
 		t.FailNow()
 	}
 }
diff --git a/gost341264/cipher_test.go b/gost341264/cipher_test.go
index 1bcf3c8..9272770 100644
--- a/gost341264/cipher_test.go
+++ b/gost341264/cipher_test.go
@@ -37,11 +37,11 @@ func TestVector(t *testing.T) {
 	c := NewCipher(key)
 	dst := make([]byte, BlockSize)
 	c.Encrypt(dst, pt[:])
-	if bytes.Compare(dst, ct[:]) != 0 {
+	if !bytes.Equal(dst, ct[:]) {
 		t.FailNow()
 	}
 	c.Decrypt(dst, dst)
-	if bytes.Compare(dst, pt[:]) != 0 {
+	if !bytes.Equal(dst, pt[:]) {
 		t.FailNow()
 	}
 }
diff --git a/internal/gost34112012/hash_test.go b/internal/gost34112012/hash_test.go
index 27c394b..1473d87 100644
--- a/internal/gost34112012/hash_test.go
+++ b/internal/gost34112012/hash_test.go
@@ -47,7 +47,7 @@ func TestVectors(t *testing.T) {
 			0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32,
 		}
 		h512.Write(m)
-		if bytes.Compare(h512.Sum(nil), []byte{
+		if !bytes.Equal(h512.Sum(nil), []byte{
 			0x1b, 0x54, 0xd0, 0x1a, 0x4a, 0xf5, 0xb9, 0xd5,
 			0xcc, 0x3d, 0x86, 0xd6, 0x8d, 0x28, 0x54, 0x62,
 			0xb1, 0x9a, 0xbc, 0x24, 0x75, 0x22, 0x2f, 0x35,
@@ -56,16 +56,16 @@ func TestVectors(t *testing.T) {
 			0x38, 0x4c, 0x65, 0x74, 0xf0, 0x24, 0xc3, 0x11,
 			0xe2, 0xa4, 0x81, 0x33, 0x2b, 0x08, 0xef, 0x7f,
 			0x41, 0x79, 0x78, 0x91, 0xc1, 0x64, 0x6f, 0x48,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		h256.Write(m)
-		if bytes.Compare(h256.Sum(nil), []byte{
+		if !bytes.Equal(h256.Sum(nil), []byte{
 			0x9d, 0x15, 0x1e, 0xef, 0xd8, 0x59, 0x0b, 0x89,
 			0xda, 0xa6, 0xba, 0x6c, 0xb7, 0x4a, 0xf9, 0x27,
 			0x5d, 0xd0, 0x51, 0x02, 0x6b, 0xb1, 0x49, 0xa4,
 			0x52, 0xfd, 0x84, 0xe5, 0xe5, 0x7b, 0x55, 0x00,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -87,7 +87,7 @@ func TestVectors(t *testing.T) {
 			0x20, 0xc8, 0xe3, 0xee, 0xf0, 0xe5, 0xe2, 0xfb,
 		}
 		h512.Write(m)
-		if bytes.Compare(h512.Sum(nil), []byte{
+		if !bytes.Equal(h512.Sum(nil), []byte{
 			0x1e, 0x88, 0xe6, 0x22, 0x26, 0xbf, 0xca, 0x6f,
 			0x99, 0x94, 0xf1, 0xf2, 0xd5, 0x15, 0x69, 0xe0,
 			0xda, 0xf8, 0x47, 0x5a, 0x3b, 0x0f, 0xe6, 0x1a,
@@ -96,16 +96,16 @@ func TestVectors(t *testing.T) {
 			0x62, 0x0f, 0xcd, 0x7c, 0x49, 0x6c, 0xe5, 0xb3,
 			0x3f, 0x0c, 0xb9, 0xdd, 0xdc, 0x2b, 0x64, 0x60,
 			0x14, 0x3b, 0x03, 0xda, 0xba, 0xc9, 0xfb, 0x28,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 		h256.Write(m)
-		if bytes.Compare(h256.Sum(nil), []byte{
+		if !bytes.Equal(h256.Sum(nil), []byte{
 			0x9d, 0xd2, 0xfe, 0x4e, 0x90, 0x40, 0x9e, 0x5d,
 			0xa8, 0x7f, 0x53, 0x97, 0x6d, 0x74, 0x05, 0xb0,
 			0xc0, 0xca, 0xc6, 0x28, 0xfc, 0x66, 0x9a, 0x74,
 			0x1d, 0x50, 0x06, 0x3c, 0x55, 0x7e, 0x8f, 0x50,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -133,12 +133,12 @@ func TestVectors(t *testing.T) {
 			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 		}
 		h256.Write(m)
-		if bytes.Compare(h256.Sum(nil), []byte{
+		if !bytes.Equal(h256.Sum(nil), []byte{
 			0xc7, 0x66, 0x08, 0x55, 0x40, 0xca, 0xaa, 0x89,
 			0x53, 0xbf, 0xcf, 0x7a, 0x1b, 0xa2, 0x20, 0x61,
 			0x9c, 0xee, 0x50, 0xd6, 0x5d, 0xc2, 0x42, 0xf8,
 			0x2f, 0x23, 0xba, 0x4b, 0x18, 0x0b, 0x18, 0xe0,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -151,7 +151,7 @@ func TestBlocksized(t *testing.T) {
 		m[i] = byte(i)
 	}
 	h.Write(m)
-	if bytes.Compare(h.Sum(nil), []byte{
+	if !bytes.Equal(h.Sum(nil), []byte{
 		0x2a, 0xe5, 0x81, 0xf1, 0x8a, 0xe8, 0x5e, 0x35,
 		0x96, 0xc9, 0x36, 0xac, 0xbe, 0xf9, 0x10, 0xf2,
 		0xed, 0x70, 0xdc, 0xf9, 0x1e, 0xd5, 0xd2, 0x4b,
@@ -160,7 +160,7 @@ func TestBlocksized(t *testing.T) {
 		0xf3, 0x0d, 0x42, 0xe1, 0x6c, 0xe2, 0x55, 0x42,
 		0x6f, 0xa8, 0xa1, 0x55, 0xdc, 0xb3, 0xeb, 0x82,
 		0x2d, 0x92, 0x58, 0x08, 0xf7, 0xc7, 0xe3, 0x45,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
@@ -169,17 +169,17 @@ func TestBehaviour(t *testing.T) {
 	h := New(64)
 	// Sum does not change the state
 	hsh1 := h.Sum(nil)
-	if bytes.Compare(h.Sum(nil), hsh1) != 0 {
+	if !bytes.Equal(h.Sum(nil), hsh1) {
 		t.FailNow()
 	}
 	// No data equals to no state changing
 	h.Write([]byte{})
-	if bytes.Compare(h.Sum(nil), hsh1) != 0 {
+	if !bytes.Equal(h.Sum(nil), hsh1) {
 		t.FailNow()
 	}
 	// Just to be sure
 	h.Write([]byte{})
-	if bytes.Compare(h.Sum(nil), hsh1) != 0 {
+	if !bytes.Equal(h.Sum(nil), hsh1) {
 		t.FailNow()
 	}
 }
@@ -199,21 +199,21 @@ func TestRandom(t *testing.T) {
 			h.Write([]byte{c})
 		}
 		d2 := h.Sum(nil)
-		if bytes.Compare(d1, d2) != 0 {
+		if !bytes.Equal(d1, d2) {
 			return false
 		}
 		h2Raw, err := h.MarshalBinary()
 		if err != nil {
 			return false
 		}
-		if bytes.Compare(h1Raw, h2Raw) != 0 {
+		if !bytes.Equal(h1Raw, h2Raw) {
 			return false
 		}
 		hNew := New(64)
 		if err = hNew.UnmarshalBinary(h1Raw); err != nil {
 			return false
 		}
-		return bytes.Compare(hNew.Sum(nil), d1) == 0
+		return bytes.Equal(hNew.Sum(nil), d1)
 	}
 	if err := quick.Check(f, nil); err != nil {
 		t.Error(err)
diff --git a/internal/gost34112012/hmac_test.go b/internal/gost34112012/hmac_test.go
index 823b51e..d8e47af 100644
--- a/internal/gost34112012/hmac_test.go
+++ b/internal/gost34112012/hmac_test.go
@@ -44,12 +44,12 @@ func TestHMACVectors(t *testing.T) {
 			0x01, 0x26, 0xbd, 0xb8, 0x78, 0x00, 0xaf, 0x21,
 			0x43, 0x41, 0x45, 0x65, 0x63, 0x78, 0x01, 0x00,
 		})
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xa1, 0xaa, 0x5f, 0x7d, 0xe4, 0x02, 0xd7, 0xb3,
 			0xd3, 0x23, 0xf2, 0x99, 0x1c, 0x8d, 0x45, 0x34,
 			0x01, 0x31, 0x37, 0x01, 0x0a, 0x83, 0x75, 0x4f,
 			0xd0, 0xaf, 0x6d, 0x7c, 0xd4, 0x92, 0x2e, 0xd9,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
@@ -65,7 +65,7 @@ func TestHMACVectors(t *testing.T) {
 			0x01, 0x26, 0xbd, 0xb8, 0x78, 0x00, 0xaf, 0x21,
 			0x43, 0x41, 0x45, 0x65, 0x63, 0x78, 0x01, 0x00,
 		})
-		if bytes.Compare(h.Sum(nil), []byte{
+		if !bytes.Equal(h.Sum(nil), []byte{
 			0xa5, 0x9b, 0xab, 0x22, 0xec, 0xae, 0x19, 0xc6,
 			0x5f, 0xbd, 0xe6, 0xe5, 0xf4, 0xe9, 0xf5, 0xd8,
 			0x54, 0x9d, 0x31, 0xf0, 0x37, 0xf9, 0xdf, 0x9b,
@@ -74,7 +74,7 @@ func TestHMACVectors(t *testing.T) {
 			0x4c, 0xb2, 0xee, 0xdc, 0x29, 0xe9, 0xad, 0x2f,
 			0x3a, 0xfe, 0x93, 0xb2, 0x81, 0x4f, 0x79, 0xf5,
 			0x00, 0x0f, 0xfc, 0x03, 0x66, 0xc2, 0x51, 0xe6,
-		}) != 0 {
+		}) {
 			t.FailNow()
 		}
 	})
diff --git a/mgm/mode_test.go b/mgm/mode_test.go
index ee49068..e364a6c 100644
--- a/mgm/mode_test.go
+++ b/mgm/mode_test.go
@@ -57,7 +57,7 @@ func TestVector(t *testing.T) {
 	nonce := plaintext[:16]
 	aead, _ := NewMGM(c, 16)
 	sealed := aead.Seal(nil, nonce, plaintext, additionalData)
-	if bytes.Compare(sealed[:len(plaintext)], []byte{
+	if !bytes.Equal(sealed[:len(plaintext)], []byte{
 		0xA9, 0x75, 0x7B, 0x81, 0x47, 0x95, 0x6E, 0x90,
 		0x55, 0xB8, 0xA3, 0x3D, 0xE8, 0x9F, 0x42, 0xFC,
 		0x80, 0x75, 0xD2, 0x21, 0x2B, 0xF9, 0xFD, 0x5B,
@@ -67,20 +67,20 @@ func TestVector(t *testing.T) {
 		0xC6, 0x0C, 0x14, 0xD4, 0xD3, 0xF8, 0x83, 0xD0,
 		0xAB, 0x94, 0x42, 0x06, 0x95, 0xC7, 0x6D, 0xEB,
 		0x2C, 0x75, 0x52,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
-	if bytes.Compare(sealed[len(plaintext):], []byte{
+	if !bytes.Equal(sealed[len(plaintext):], []byte{
 		0xCF, 0x5D, 0x65, 0x6F, 0x40, 0xC3, 0x4F, 0x5C,
 		0x46, 0xE8, 0xBB, 0x0E, 0x29, 0xFC, 0xDB, 0x4C,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 	_, err := aead.Open(sealed[:0], nonce, sealed, additionalData)
 	if err != nil {
 		t.FailNow()
 	}
-	if bytes.Compare(sealed[:len(plaintext)], plaintext) != 0 {
+	if !bytes.Equal(sealed[:len(plaintext)], plaintext) {
 		t.FailNow()
 	}
 }
@@ -102,7 +102,7 @@ func TestSymmetric(t *testing.T) {
 			}
 			for _, initial := range initials {
 				sealed := aead.Seal(initial, nonce, plaintext, additionalData)
-				if bytes.Compare(sealed[:len(initial)], initial) != 0 {
+				if !bytes.Equal(sealed[:len(initial)], initial) {
 					return false
 				}
 				pt, err := aead.Open(
@@ -111,7 +111,7 @@ func TestSymmetric(t *testing.T) {
 					sealed[len(initial):],
 					additionalData,
 				)
-				if err != nil || bytes.Compare(pt, plaintext) != 0 {
+				if err != nil || !bytes.Equal(pt, plaintext) {
 					return false
 				}
 			}
diff --git a/mgm/mul128.go b/mgm/mul128.go
index 10511a7..a72ad26 100644
--- a/mgm/mul128.go
+++ b/mgm/mul128.go
@@ -45,7 +45,8 @@ func (mul *mul128) Mul(x, y []byte) []byte {
 	x0 := binary.BigEndian.Uint64(x[8:])
 	y1 := binary.BigEndian.Uint64(y[:8])
 	y0 := binary.BigEndian.Uint64(y[8:])
-	t, x0, x1, z0, z1 := gf128half(64, y0, x0, x1, 0, 0)
+	var t uint64
+	_, x0, x1, z0, z1 := gf128half(64, y0, x0, x1, 0, 0)
 	t, x0, x1, z0, z1 = gf128half(63, y1, x0, x1, z0, z1)
 	if t&1 > 0 {
 		z0, z1 = z0^x0, z1^x1
diff --git a/prfplus/gost_test.go b/prfplus/gost_test.go
index 5538565..95677f4 100644
--- a/prfplus/gost_test.go
+++ b/prfplus/gost_test.go
@@ -32,7 +32,7 @@ func TestPRFIPsecPRFPlusGOSTR34112012256(t *testing.T) {
 		0x01, 0x26, 0xBD, 0xB8, 0x78, 0x00, 0x1D, 0x80,
 		0x60, 0x3C, 0x85, 0x44, 0xC7, 0x27, 0x01, 0x00,
 	})
-	if bytes.Compare(dst, []byte{
+	if !bytes.Equal(dst, []byte{
 		0x2D, 0xE5, 0xEE, 0x84, 0xE1, 0x3D, 0x7B, 0xE5,
 		0x36, 0x16, 0x67, 0x39, 0x13, 0x37, 0x0A, 0xB0,
 		0x54, 0xC0, 0x74, 0xB7, 0x9B, 0x69, 0xA8, 0xA8,
@@ -41,7 +41,7 @@ func TestPRFIPsecPRFPlusGOSTR34112012256(t *testing.T) {
 		0xAA, 0x2E, 0xF9, 0x5D, 0x7A, 0x59, 0xBE, 0x95,
 		0x4D, 0xE0, 0x08, 0xF4, 0xA5, 0x0D, 0x50, 0x4D,
 		0xBD, 0xB6, 0x90, 0xBE, 0x68, 0x06, 0x01, 0x53,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }
@@ -58,7 +58,7 @@ func TestPRFIPsecPRFPlusGOSTR34112012512(t *testing.T) {
 		0x01, 0x26, 0xBD, 0xB8, 0x78, 0x00, 0x1D, 0x80,
 		0x60, 0x3C, 0x85, 0x44, 0xC7, 0x27, 0x01, 0x00,
 	})
-	if bytes.Compare(dst, []byte{
+	if !bytes.Equal(dst, []byte{
 		0x5D, 0xA6, 0x71, 0x43, 0xA5, 0xF1, 0x2A, 0x6D,
 		0x6E, 0x47, 0x42, 0x59, 0x6F, 0x39, 0x24, 0x3F,
 		0xCC, 0x61, 0x57, 0x45, 0x91, 0x5B, 0x32, 0x59,
@@ -75,7 +75,7 @@ func TestPRFIPsecPRFPlusGOSTR34112012512(t *testing.T) {
 		0x8B, 0xE5, 0xC1, 0xEF, 0xA1, 0xAF, 0xA9, 0x5E,
 		0xBE, 0x83, 0xE3, 0x9D, 0x00, 0xE1, 0x9A, 0x5D,
 		0x03, 0xDC, 0xD6, 0x0A, 0x01, 0xBC, 0xA8, 0xE3,
-	}) != 0 {
+	}) {
 		t.FailNow()
 	}
 }