gost3410/private_test.go

   1 // GoGOST -- Pure Go GOST cryptographic functions library
   2 // Copyright (C) 2015-2023 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, version 3 of the License.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 package gost3410
  17
  18 import (
  19         "crypto"
  20         "crypto/rand"
  21         "io"
  22         "testing"
  23 )
  24
  25 func TestSignerInterface(t *testing.T) {
  26         c := CurveIdGostR34102001TestParamSet()
  27         prvRaw := make([]byte, c.PointSize())
  28         _, err := io.ReadFull(rand.Reader, prvRaw)
  29         if err != nil {
  30                 t.Fatal(err)
  31         }
  32         prv, err := NewPrivateKey(c, prvRaw)
  33         if err != nil {
  34                 t.Fatal(err)
  35         }
  36         var _ crypto.Signer = prv
  37         var _ crypto.Signer = &PrivateKeyReverseDigest{prv}
  38         var _ crypto.Signer = &PrivateKeyReverseDigestAndSignature{prv}
  39 }
  40
  41 func TestSignerReverseDigest(t *testing.T) {
  42         dgst := make([]byte, 32)
  43         _, err := io.ReadFull(rand.Reader, dgst)
  44         if err != nil {
  45                 t.Fatal(err)
  46         }
  47         prv0, err := GenPrivateKey(CurveIdGostR34102001TestParamSet(), rand.Reader)
  48         if err != nil {
  49                 t.Fatal(err)
  50         }
  51         pub0 := prv0.Public().(*PublicKey)
  52         sign, err := prv0.Sign(rand.Reader, dgst, nil)
  53         if err != nil {
  54                 t.Fatal(err)
  55         }
  56         valid, err := pub0.VerifyDigest(dgst, sign)
  57         if err != nil {
  58                 t.Fatal(err)
  59         }
  60         if !valid {
  61                 t.FailNow()
  62         }
  63         var _ crypto.PublicKey = pub0
  64
  65         prv1 := PrivateKeyReverseDigest{prv0}
  66         pub1 := PublicKeyReverseDigest{prv1.Public().(*PublicKey)}
  67         sign, err = prv1.Sign(rand.Reader, dgst, nil)
  68         if err != nil {
  69                 t.Fatal(err)
  70         }
  71         valid, err = pub1.VerifyDigest(dgst, sign)
  72         if err != nil {
  73                 t.Fatal(err)
  74         }
  75         if !valid {
  76                 t.FailNow()
  77         }
  78
  79         prv2 := PrivateKeyReverseDigestAndSignature{prv0}
  80         pub2 := PublicKeyReverseDigestAndSignature{prv2.Public().(*PublicKey)}
  81         sign, err = prv2.Sign(rand.Reader, dgst, nil)
  82         if err != nil {
  83                 t.Fatal(err)
  84         }
  85         valid, err = pub2.VerifyDigest(dgst, sign)
  86         if err != nil {
  87                 t.Fatal(err)
  88         }
  89         if !valid {
  90                 t.FailNow()
  91         }
  92 }