github.com/insolar/vanilla@v0.0.0-20201023172447-248fdf805322/cryptkit/containers_test.go (about)

     1  // Copyright 2020 Insolar Network Ltd.
     2  // All rights reserved.
     3  // This material is licensed under the Insolar License version 1.0,
     4  // available at https://github.com/insolar/assured-ledger/blob/master/LICENSE.md.
     5  
     6  package cryptkit
     7  
     8  import (
     9  	"bytes"
    10  	"hash/crc32"
    11  	"io"
    12  	"strings"
    13  	"testing"
    14  
    15  	"github.com/stretchr/testify/require"
    16  
    17  	"github.com/insolar/vanilla/longbits"
    18  )
    19  
    20  func TestCompareNil(t *testing.T) {
    21  	var s1, s2 Signature
    22  	require.Equal(t, 0, s1.FixedByteSize())
    23  	require.True(t, s1.Equals(s2))
    24  }
    25  
    26  func TestCompareNilZero(t *testing.T) {
    27  	require.Equal(t, 0, Digest{}.FixedByteSize())
    28  	require.Equal(t, DigestMethod(""), Digest{}.GetDigestMethod())
    29  	require.Nil(t, Digest{}.AsDigestHolder())
    30  	require.True(t, Digest{}.IsEmpty())
    31  	require.True(t, Digest{}.IsZero())
    32  
    33  	require.Equal(t, 0, Signature{}.FixedByteSize())
    34  	require.Equal(t, SignatureMethod(""), Signature{}.GetSignatureMethod())
    35  	require.Nil(t, Signature{}.AsSignatureHolder())
    36  	require.True(t, Signature{}.IsEmpty())
    37  
    38  	require.Equal(t, 0, SigningKey{}.FixedByteSize())
    39  	require.Equal(t, SigningMethod(""), SigningKey{}.GetSigningMethod())
    40  	require.True(t, SigningKey{}.IsEmpty())
    41  
    42  	require.Equal(t, 0, SignedData{}.FixedByteSize())
    43  	require.True(t, SignedData{}.IsEmpty())
    44  }
    45  
    46  func TestIsSymmetric(t *testing.T) {
    47  	require.True(t, SymmetricKey.IsSymmetric())
    48  
    49  	require.False(t, PublicAsymmetricKey.IsSymmetric())
    50  }
    51  
    52  func TestIsSecret(t *testing.T) {
    53  	require.True(t, SymmetricKey.IsSecret())
    54  
    55  	require.False(t, PublicAsymmetricKey.IsSecret())
    56  }
    57  
    58  func TestSignedBy(t *testing.T) {
    59  	td := "testDigest"
    60  	ts := "testSign"
    61  	require.Equal(t, SignatureMethod(strings.Join([]string{td, ts}, "/")), DigestMethod(td).SignedBy(SigningMethod(ts)))
    62  }
    63  
    64  func TestDigestMethodString(t *testing.T) {
    65  	td := "test"
    66  	d := DigestMethod(td)
    67  	require.Equal(t, td, d.String())
    68  }
    69  
    70  func TestSignMethodString(t *testing.T) {
    71  	ts := "test"
    72  	s := SigningMethod(ts)
    73  	require.Equal(t, ts, s.String())
    74  }
    75  
    76  func TestDigestMethod(t *testing.T) {
    77  	td := "testDigest"
    78  	ts := "testSign"
    79  	sep := "/"
    80  	require.Equal(t, DigestMethod(td), SignatureMethod(strings.Join([]string{td, ts}, sep)).DigestMethod())
    81  
    82  	emptyDigMethod := DigestMethod("")
    83  	require.Equal(t, emptyDigMethod, SignatureMethod("testSignature").DigestMethod())
    84  
    85  	require.Equal(t, emptyDigMethod, SignatureMethod(strings.Join([]string{td, ts, "test"}, sep)).DigestMethod())
    86  }
    87  
    88  func TestSignMethod(t *testing.T) {
    89  	td := "testDigest"
    90  	ts := "testSign"
    91  	sep := "/"
    92  	require.Equal(t, SigningMethod(ts), SignatureMethod(strings.Join([]string{td, ts}, sep)).SigningMethod())
    93  
    94  	emptySignMethod := SigningMethod("")
    95  	require.Equal(t, emptySignMethod, SignatureMethod("testSignature").SigningMethod())
    96  
    97  	require.Equal(t, emptySignMethod, SignatureMethod(strings.Join([]string{td, ts, "test"}, sep)).SigningMethod())
    98  }
    99  
   100  func TestString(t *testing.T) {
   101  	ts := "test"
   102  	sm := SignatureMethod(ts)
   103  	require.Equal(t, ts, sm.String())
   104  }
   105  
   106  func TestDigestEquals(t *testing.T) {
   107  	bits := longbits.NewBits64(0)
   108  	d := NewDigest(&bits, "")
   109  	dc := NewDigest(&bits, "")
   110  	require.True(t, d.Equals(dc.AsDigestHolder()))
   111  }
   112  
   113  func TestNewDigest(t *testing.T) {
   114  	fd := longbits.NewFoldableReaderMock(t)
   115  	method := DigestMethod("test")
   116  	d := NewDigest(fd, method)
   117  	require.Equal(t, fd, d.hFoldReader)
   118  
   119  	require.Equal(t, method, d.digestMethod)
   120  }
   121  
   122  func TestSignWith(t *testing.T) {
   123  	ds := NewDigestSignerMock(t)
   124  	sm := SignatureMethod("test")
   125  	ds.SignDigestMock.Set(func(Digest) Signature { return Signature{signatureMethod: sm} })
   126  	d := &Digest{}
   127  	sd := d.SignWith(ds)
   128  	require.Equal(t, sm, sd.GetSignatureMethod())
   129  }
   130  
   131  func TestDigestString(t *testing.T) {
   132  	require.True(t, Digest{}.String() != "")
   133  }
   134  
   135  func TestCopyOfSignature(t *testing.T) {
   136  	s := &Signature{signatureMethod: "test"}
   137  	fd := longbits.NewFoldableReaderMock(t)
   138  	fd.FixedByteSizeMock.Set(func() int { return 0 })
   139  	fd.CopyToMock.Set(func(p []byte) int { return 0 })
   140  	s.hFoldReader = fd
   141  	cs := s.CopyOfSignature()
   142  	require.Equal(t, cs.signatureMethod, s.signatureMethod)
   143  }
   144  
   145  func TestNewSignature(t *testing.T) {
   146  	fd := longbits.NewFoldableReaderMock(t)
   147  	method := SignatureMethod("test")
   148  	s := NewSignature(fd, method)
   149  	require.Equal(t, fd, s.hFoldReader)
   150  
   151  	require.Equal(t, method, s.signatureMethod)
   152  }
   153  
   154  func TestSignatureEquals(t *testing.T) {
   155  	bits := longbits.NewBits64(0)
   156  	s := NewSignature(&bits, "")
   157  	sc := NewSignature(&bits, "")
   158  	require.True(t, s.Equals(sc.AsSignatureHolder()))
   159  }
   160  
   161  func TestSignGetSignatureMethod(t *testing.T) {
   162  	ts := SignatureMethod("test")
   163  	signature := NewSignature(nil, ts)
   164  	require.Equal(t, ts, signature.GetSignatureMethod())
   165  }
   166  
   167  func TestAsSignatureHolder(t *testing.T) {
   168  	fd := longbits.NewFoldableReaderMock(t)
   169  	s := Signature{hFoldReader: fd, signatureMethod: "test"}
   170  	sh := s.AsSignatureHolder()
   171  	require.Equal(t, sh.GetSignatureMethod(), s.signatureMethod)
   172  
   173  	require.Implements(t, (*SignatureHolder)(nil), sh)
   174  }
   175  
   176  func TestSignatureString(t *testing.T) {
   177  	require.True(t, Signature{}.String() != "")
   178  }
   179  
   180  func TestNewSignedDigest(t *testing.T) {
   181  	d := Digest{digestMethod: "testDigest"}
   182  	s := Signature{signatureMethod: "testSignature"}
   183  	sd := NewSignedDigest(d, s)
   184  	require.Equal(t, d.digestMethod, sd.digest.digestMethod)
   185  
   186  	require.Equal(t, s.signatureMethod, sd.GetSignatureMethod())
   187  }
   188  
   189  func TestCopyOfSignedDigest(t *testing.T) {
   190  	d := Digest{digestMethod: "testDigest"}
   191  	fd1 := longbits.NewFoldableReaderMock(t)
   192  	fd1.FixedByteSizeMock.Set(func() int { return 0 })
   193  	fd1.CopyToMock.Set(func(p []byte) int { return 0 })
   194  	d.hFoldReader = fd1
   195  
   196  	s := Signature{signatureMethod: "testSignature"}
   197  	fd2 := longbits.NewFoldableReaderMock(t)
   198  	fd2.FixedByteSizeMock.Set(func() int { return 0 })
   199  	fd2.CopyToMock.Set(func(p []byte) int { return 0 })
   200  	s.hFoldReader = fd2
   201  	sd := NewSignedDigest(d, s)
   202  	require.Equal(t, s.GetSignatureMethod(), sd.GetSignatureMethod())
   203  }
   204  
   205  func TestSignedDigestEquals(t *testing.T) {
   206  	dBits := longbits.NewBits64(0)
   207  	d := NewDigest(&dBits, "")
   208  
   209  	sBits1 := longbits.NewBits64(0)
   210  	s := NewSignature(&sBits1, "")
   211  
   212  	sd1 := NewSignedDigest(d, s)
   213  	sd2 := NewSignedDigest(d, s)
   214  	require.True(t, sd1.Equals(&sd2))
   215  
   216  	sBits2 := longbits.NewBits64(1)
   217  	sd2 = NewSignedDigest(d, NewSignature(&sBits2, ""))
   218  	require.False(t, sd1.Equals(&sd2))
   219  }
   220  
   221  func TestGetDigest(t *testing.T) {
   222  	fd := longbits.NewFoldableReaderMock(t)
   223  	d := Digest{hFoldReader: fd, digestMethod: "test"}
   224  	s := Signature{}
   225  	sd := NewSignedDigest(d, s)
   226  	require.Equal(t, fd, sd.GetDigest().hFoldReader)
   227  
   228  	require.Equal(t, d.digestMethod, sd.GetDigest().digestMethod)
   229  }
   230  
   231  func TestGetSignature(t *testing.T) {
   232  	fd := longbits.NewFoldableReaderMock(t)
   233  	d := Digest{}
   234  	s := Signature{hFoldReader: fd, signatureMethod: "test"}
   235  	sd := NewSignedDigest(d, s)
   236  	require.Equal(t, fd, sd.GetSignature().hFoldReader)
   237  
   238  	require.Equal(t, s.signatureMethod, sd.GetSignature().signatureMethod)
   239  }
   240  
   241  func TestGetDigestHolder(t *testing.T) {
   242  	fd := longbits.NewFoldableReaderMock(t)
   243  	d := Digest{hFoldReader: fd, digestMethod: "testDigest"}
   244  	s := Signature{hFoldReader: fd, signatureMethod: "testSignature"}
   245  	sd := NewSignedDigest(d, s)
   246  	require.Equal(t, d.AsDigestHolder(), sd.GetDigestHolder())
   247  }
   248  
   249  func TestGetSignatureHolder(t *testing.T) {
   250  	fd := longbits.NewFoldableReaderMock(t)
   251  	d := Digest{hFoldReader: fd, digestMethod: "testDigest"}
   252  	s := Signature{hFoldReader: fd, signatureMethod: "testSignature"}
   253  	sd := NewSignedDigest(d, s)
   254  	require.Equal(t, s.AsSignatureHolder(), sd.GetSignatureHolder())
   255  }
   256  
   257  func TestSignedDigGetSignatureMethod(t *testing.T) {
   258  	s := Signature{signatureMethod: "test"}
   259  	sd := NewSignedDigest(Digest{}, s)
   260  	require.Equal(t, s.signatureMethod, sd.GetSignatureMethod())
   261  }
   262  
   263  func TestIsVerifiableBy(t *testing.T) {
   264  	sd := NewSignedDigest(Digest{}, Signature{})
   265  	sv := NewSignatureVerifierMock(t)
   266  	supported := false
   267  	sv.IsSigningMethodSupportedMock.Set(func(SigningMethod) bool { return *(&supported) })
   268  	require.False(t, sd.IsVerifiableBy(sv))
   269  
   270  	supported = true
   271  	require.True(t, sd.IsVerifiableBy(sv))
   272  }
   273  
   274  func TestVerifyWith(t *testing.T) {
   275  	sd := NewSignedDigest(Digest{}, Signature{})
   276  	sv := NewSignatureVerifierMock(t)
   277  	valid := false
   278  	sv.IsValidDigestSignatureMock.Set(func(DigestHolder, SignatureHolder) bool { return *(&valid) })
   279  	require.False(t, sd.VerifyWith(sv))
   280  
   281  	valid = true
   282  	require.True(t, sd.VerifyWith(sv))
   283  }
   284  
   285  func TestSignedDigestString(t *testing.T) {
   286  	require.True(t, NewSignedDigest(Digest{}, Signature{}).String() != "")
   287  }
   288  
   289  func TestAsSignedDigestHolder(t *testing.T) {
   290  	fd := longbits.NewFoldableReaderMock(t)
   291  	d := Digest{hFoldReader: fd, digestMethod: "testDigest"}
   292  	s := Signature{hFoldReader: fd, signatureMethod: "testSignature"}
   293  	sd := NewSignedDigest(d, s)
   294  	sdh := sd.AsSignedDigestHolder()
   295  
   296  	require.Equal(t, sdh.GetSignatureMethod(), s.signatureMethod)
   297  
   298  	require.Implements(t, (*SignedDigestHolder)(nil), sdh)
   299  }
   300  
   301  func TestNewSignedData(t *testing.T) {
   302  	bits := longbits.NewBits64(0)
   303  	d := Digest{digestMethod: "testDigest"}
   304  	s := Signature{signatureMethod: "testSignature"}
   305  	sd := NewSignedData(&bits, d, s)
   306  	require.Equal(t, &bits, sd.hWriterTo)
   307  
   308  	require.Equal(t, d, sd.hSignedDigest.digest)
   309  
   310  	require.Equal(t, s, sd.hSignedDigest.signature)
   311  }
   312  
   313  func TestGetSignedDigest(t *testing.T) {
   314  	bits := longbits.NewBits64(0)
   315  	d := Digest{digestMethod: "testDigest"}
   316  	s := Signature{signatureMethod: "testSignature"}
   317  	sd := NewSignedData(&bits, d, s)
   318  	signDig := sd.GetSignedDigest()
   319  	require.Equal(t, d, signDig.digest)
   320  
   321  	require.Equal(t, s, signDig.signature)
   322  }
   323  
   324  func TestWriteTo(t *testing.T) {
   325  	bits1 := longbits.NewBits64(1)
   326  	d := Digest{digestMethod: "testDigest"}
   327  	s := Signature{signatureMethod: "testSignature"}
   328  	sd := NewSignedData(&bits1, d, s)
   329  	buf := &bytes.Buffer{}
   330  	n, err := sd.WriteTo(buf)
   331  	require.Equal(t, int64(8), n)
   332  
   333  	require.Nil(t, err)
   334  }
   335  
   336  func TestSignedDataString(t *testing.T) {
   337  	bits := longbits.NewBits64(0)
   338  	require.NotEmpty(t, NewSignedData(&bits, Digest{}, Signature{}).String())
   339  }
   340  
   341  func TestNewSignatureKey(t *testing.T) {
   342  	fd := longbits.NewFoldableReaderMock(t)
   343  	ts := SigningMethod("testSign")
   344  	kt := PublicAsymmetricKey
   345  	sk := NewSigningKey(fd, ts, kt)
   346  	require.Equal(t, fd, sk.hFoldReader)
   347  
   348  	require.Equal(t, ts, sk.method)
   349  
   350  	require.Equal(t, kt, sk.keyType)
   351  }
   352  
   353  func TestGetSignMethod(t *testing.T) {
   354  	fd := longbits.NewFoldableReaderMock(t)
   355  	ts := "testSign"
   356  	sk := NewSigningKey(fd, SigningMethod(ts), PublicAsymmetricKey)
   357  	require.Equal(t, ts, sk.GetSigningMethod().String())
   358  }
   359  
   360  func TestGetSignatureKeyMethod(t *testing.T) {
   361  	fd := longbits.NewFoldableReaderMock(t)
   362  	s := SigningMethod("testSign")
   363  	sk := NewSigningKey(fd, s, PublicAsymmetricKey)
   364  	require.Equal(t, s, sk.GetSigningMethod())
   365  }
   366  
   367  func TestGetSignatureKeyType(t *testing.T) {
   368  	fd := longbits.NewFoldableReaderMock(t)
   369  	kt := PublicAsymmetricKey
   370  	sk := NewSigningKey(fd, "test", kt)
   371  	require.Equal(t, kt, sk.GetSigningKeyType())
   372  }
   373  
   374  func TestEquals(t *testing.T) {
   375  	fd := longbits.NewFoldableReaderMock(t)
   376  	fd.FixedByteSizeMock.Set(func() int { return 0 })
   377  	fd.WriteToMock.Set(func(io.Writer) (int64, error) { return 0, nil })
   378  	sk1 := NewSigningKey(fd, "test", PublicAsymmetricKey)
   379  	sk2 := NewSigningKey(fd, "test", PublicAsymmetricKey)
   380  	require.True(t, sk1.Equals(&sk2))
   381  }
   382  
   383  func TestSignatureKeyString(t *testing.T) {
   384  	fd := longbits.NewFoldableReaderMock(t)
   385  	sk := NewSigningKey(fd, "test", PublicAsymmetricKey)
   386  	require.NotEmpty(t, sk.String())
   387  }
   388  
   389  func TestSignDataByDataSigner(t *testing.T) {
   390  	signer := NewDataSignerMock(t)
   391  	signer.GetDigestSizeMock.Return(4)
   392  	signer.GetDigestMethodMock.Return("testMethod")
   393  	signer.NewHasherMock.Return(DigestHasher{BasicDigester: signer, Hash: crc32.NewIEEE()})
   394  	data := longbits.WrapStr("testString")
   395  	hasher := crc32.NewIEEE()
   396  	_, _ = data.WriteTo(hasher)
   397  
   398  	signer.SignDigestMock.Expect(NewDigest(longbits.WrapBytes(hasher.Sum(nil)), "testMethod"))
   399  	signer.SignDigestMock.Return(Signature{})
   400  	sdata := SignDataByDataSigner(data, signer)
   401  	require.True(t, longbits.Equal(data, sdata))
   402  }
   403  
   404  func TestNewZeroSizeDigest(t *testing.T) {
   405  	d := NewZeroSizeDigest("test")
   406  	require.Equal(t, 0, d.FixedByteSize())
   407  	require.Equal(t, DigestMethod("test"), d.GetDigestMethod())
   408  	require.NotNil(t, d.AsDigestHolder())
   409  	require.False(t, d.IsEmpty())
   410  	require.False(t, d.IsZero())
   411  }