Modern rand.Read never fails

diff --git a/README b/README
index 227f3a4a9b5f5e1f51712561ad4a77dd3a345158..000d7b70423bd4b5fef61cda154c04c302716891 100644 (file)
--- a/README
+++ b/README
@@ -44,11 +44,11 @@ Example 34.10-2012-256 keypair generation, signing and verifying:
     func main() {
         data := []byte("data to be signed")
         hasher := gost34112012256.New()
-        _, err := hasher.Write(data)
+        hasher.Write(data)
         dgst := hasher.Sum(nil)
         curve := gost3410.CurveIdtc26gost341012256paramSetB()
-        prvRaw := make([]byte, int(32))
-        _, err = io.ReadFull(rand.Reader, prvRaw)
+        prvRaw := make([]byte, curve.PointSize())
+        rand.Read(prvRaw)
         prv, err := gost3410.NewPrivateKey(curve, prvRaw)
         pub, err := prv.PublicKey()
         pubRaw := pub.Raw()

diff --git a/cmd/cer-selfsigned-example/main.go b/cmd/cer-selfsigned-example/main.go
index 461c922a236b25a1d3e8b2568d580f017f1fcc25..5e19ad6e24e0ee18941499a9dc4e747f8302bb84 100644 (file)
--- a/cmd/cer-selfsigned-example/main.go
+++ b/cmd/cer-selfsigned-example/main.go
@@ -24,7 +24,6 @@ import (
        "crypto/x509/pkix"
        "encoding/pem"
        "flag"
-       "io"
        "log"
        "math/big"
        "os"
@@ -120,9 +119,7 @@ func main() {
        var prv any
        if *reuseKey == "" {
                prvRaw := make([]byte, curve.PointSize())
-               if _, err = io.ReadFull(rand.Reader, prvRaw); err != nil {
-                       log.Fatal(err)
-               }
+               rand.Read(prvRaw)
                prv, err = gost3410.NewPrivateKey(curve, prvRaw)
                if err != nil {
                        log.Fatal(err)
@@ -161,9 +158,7 @@ func main() {
        sn := big.NewInt(0)
        if *serial == -1 {
                data := make([]byte, 16, gost34112012256.Size)
-               if _, err = io.ReadFull(rand.Reader, data); err != nil {
-                       log.Fatal(err)
-               }
+               rand.Read(data)
                hasher := gost34112012256.New()
                if _, err = hasher.Write(data); err != nil {
                        log.Fatal(err)

diff --git a/gost28147/wrap_test.go b/gost28147/wrap_test.go
index 2d144cdd04bd565a2c5033b7a7a2d9bee7a79f74..abdb04511c346f7d363128021b428991e0c95094 100644 (file)
--- a/gost28147/wrap_test.go
+++ b/gost28147/wrap_test.go
@@ -3,7 +3,6 @@ package gost28147
 import (
        "bytes"
        "crypto/rand"
-       "io"
        "testing"
 )
 
@@ -12,15 +11,9 @@ func TestWrapSymmetric(t *testing.T) {
        cek := make([]byte, KeySize)
        ukm := make([]byte, 8)
        for range 1000 {
-               if _, err := io.ReadFull(rand.Reader, kek); err != nil {
-                       t.Fatal(err)
-               }
-               if _, err := io.ReadFull(rand.Reader, cek); err != nil {
-                       t.Fatal(err)
-               }
-               if _, err := io.ReadFull(rand.Reader, ukm); err != nil {
-                       t.Fatal(err)
-               }
+               rand.Read(kek)
+               rand.Read(cek)
+               rand.Read(ukm)
                data := WrapGost(ukm, kek, cek)
                got := UnwrapGost(kek, data)
                if !bytes.Equal(got, cek) {

diff --git a/gost3412128/cipher_test.go b/gost3412128/cipher_test.go
index 589198bd2ec8ab358863860ce6935522bb1effef..c0d1f8f35ad7e39d7b6904699bcaa3a2398dd80a 100644 (file)
--- a/gost3412128/cipher_test.go
+++ b/gost3412128/cipher_test.go
@@ -48,7 +48,7 @@ func TestCipherInterface(t *testing.T) {
 func TestRandom(t *testing.T) {
        data := make([]byte, BlockSize)
        f := func(key [KeySize]byte, pt [BlockSize]byte) bool {
-               io.ReadFull(rand.Reader, key[:])
+               rand.Read(key[:])
                c := NewCipher(key[:])
                c.Encrypt(data, pt[:])
                c.Decrypt(data, data)
@@ -61,7 +61,7 @@ func TestRandom(t *testing.T) {
 
 func BenchmarkEncrypt(b *testing.B) {
        key := make([]byte, KeySize)
-       io.ReadFull(rand.Reader, key)
+       rand.Read(key)
        c := NewCipher(key)
        blk := make([]byte, BlockSize)
        for b.Loop() {

diff --git a/mgm/mode_test.go b/mgm/mode_test.go
index d1f65f740f7e540acd46fffa1e71d70871e01816..c498c953a92f83e68946cab7fa71c72f18c75912 100644 (file)
--- a/mgm/mode_test.go
+++ b/mgm/mode_test.go
@@ -19,7 +19,6 @@ import (
        "bytes"
        "crypto/cipher"
        "crypto/rand"
-       "io"
        "testing"
        "testing/quick"
 
@@ -123,13 +122,9 @@ func TestSymmetric(t *testing.T) {
        }
 
        key128 := new([gost3412128.KeySize]byte)
-       if _, err := rand.Read(key128[:]); err != nil {
-               panic(err)
-       }
+       rand.Read(key128[:])
        nonce := make([]byte, gost3412128.BlockSize)
-       if _, err := rand.Read(key128[1:]); err != nil {
-               panic(err)
-       }
+       rand.Read(key128[1:])
        sym(
                gost3412128.BlockSize,
                gost3412128.NewCipher(key128[:]),
@@ -147,18 +142,12 @@ func TestSymmetric(t *testing.T) {
 
 func BenchmarkMGM64(b *testing.B) {
        key := make([]byte, gost341264.KeySize)
-       if _, err := io.ReadFull(rand.Reader, key); err != nil {
-               panic(err)
-       }
+       rand.Read(key)
        nonce := make([]byte, gost341264.BlockSize)
-       if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-               panic(err)
-       }
+       rand.Read(nonce)
        nonce[0] &= 0x7F
        pt := make([]byte, 1280+3)
-       if _, err := io.ReadFull(rand.Reader, pt); err != nil {
-               panic(err)
-       }
+       rand.Read(pt)
        c := gost341264.NewCipher(key)
        aead, err := NewMGM(c, gost341264.BlockSize)
        if err != nil {
@@ -172,18 +161,12 @@ func BenchmarkMGM64(b *testing.B) {
 
 func BenchmarkMGM128(b *testing.B) {
        key := make([]byte, gost3412128.KeySize)
-       if _, err := io.ReadFull(rand.Reader, key); err != nil {
-               panic(err)
-       }
+       rand.Read(key)
        nonce := make([]byte, gost3412128.BlockSize)
-       if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-               panic(err)
-       }
+       rand.Read(nonce)
        nonce[0] &= 0x7F
        pt := make([]byte, 1280+3)
-       if _, err := io.ReadFull(rand.Reader, pt); err != nil {
-               panic(err)
-       }
+       rand.Read(pt)
        c := gost3412128.NewCipher(key)
        aead, err := NewMGM(c, gost3412128.BlockSize)
        if err != nil {

diff --git a/www.texi b/www.texi
index 36bf59a990ac73366054589f167376620f253d3e..c9733b1448b0182c392d28921786e55c0ea09e69 100644 (file)
--- a/www.texi
+++ b/www.texi
@@ -72,11 +72,11 @@ import (
 func main() {
     data := []byte("data to be signed")
     hasher := gost34112012256.New()
-    _, err := hasher.Write(data)
+    hasher.Write(data)
     dgst := hasher.Sum(nil)
     curve := gost3410.CurveIdtc26gost341012256paramSetB()
-    prvRaw := make([]byte, 32)
-    _, err = io.ReadFull(rand.Reader, prvRaw)
+    prvRaw := make([]byte, curve.PointSize())
+    rand.Read(prvRaw)
     prv, err := gost3410.NewPrivateKey(curve, prvRaw)
     pub, err := prv.PublicKey()
     pubRaw := pub.Raw()