github.com/lzy4123/fabric@v2.1.1+incompatible/bccsp/sw/sw_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8  		 http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package sw
    18  
    19  import (
    20  	"errors"
    21  	"reflect"
    22  	"testing"
    23  
    24  	"github.com/hyperledger/fabric/bccsp"
    25  	"github.com/hyperledger/fabric/bccsp/mocks"
    26  	mocks2 "github.com/hyperledger/fabric/bccsp/sw/mocks"
    27  	"github.com/stretchr/testify/assert"
    28  )
    29  
    30  func TestKeyGenInvalidInputs(t *testing.T) {
    31  	// Init a BCCSP instance with a key store that returns an error on store
    32  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{StoreKeyErr: errors.New("cannot store key")})
    33  	assert.NoError(t, err)
    34  
    35  	_, err = csp.KeyGen(nil)
    36  	assert.Error(t, err)
    37  	assert.Contains(t, err.Error(), "Invalid Opts parameter. It must not be nil.")
    38  
    39  	_, err = csp.KeyGen(&mocks.KeyGenOpts{})
    40  	assert.Error(t, err)
    41  	assert.Contains(t, err.Error(), "Unsupported 'KeyGenOpts' provided [")
    42  
    43  	_, err = csp.KeyGen(&bccsp.ECDSAP256KeyGenOpts{})
    44  	assert.Error(t, err, "Generation of a non-ephemeral key must fail. KeyStore is programmed to fail.")
    45  	assert.Contains(t, err.Error(), "cannot store key")
    46  }
    47  
    48  func TestKeyDerivInvalidInputs(t *testing.T) {
    49  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{StoreKeyErr: errors.New("cannot store key")})
    50  	assert.NoError(t, err)
    51  
    52  	_, err = csp.KeyDeriv(nil, &bccsp.ECDSAReRandKeyOpts{})
    53  	assert.Error(t, err)
    54  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
    55  
    56  	_, err = csp.KeyDeriv(&mocks.MockKey{}, nil)
    57  	assert.Error(t, err)
    58  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
    59  
    60  	_, err = csp.KeyDeriv(&mocks.MockKey{}, &bccsp.ECDSAReRandKeyOpts{})
    61  	assert.Error(t, err)
    62  	assert.Contains(t, err.Error(), "Unsupported 'Key' provided [")
    63  
    64  	keyDerivers := make(map[reflect.Type]KeyDeriver)
    65  	keyDerivers[reflect.TypeOf(&mocks.MockKey{})] = &mocks2.KeyDeriver{
    66  		KeyArg:  &mocks.MockKey{},
    67  		OptsArg: &mocks.KeyDerivOpts{EphemeralValue: false},
    68  		Value:   nil,
    69  		Err:     nil,
    70  	}
    71  	csp.(*CSP).KeyDerivers = keyDerivers
    72  	_, err = csp.KeyDeriv(&mocks.MockKey{}, &mocks.KeyDerivOpts{EphemeralValue: false})
    73  	assert.Error(t, err, "KeyDerivation of a non-ephemeral key must fail. KeyStore is programmed to fail.")
    74  	assert.Contains(t, err.Error(), "cannot store key")
    75  }
    76  
    77  func TestKeyImportInvalidInputs(t *testing.T) {
    78  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
    79  	assert.NoError(t, err)
    80  
    81  	_, err = csp.KeyImport(nil, &bccsp.AES256ImportKeyOpts{})
    82  	assert.Error(t, err)
    83  	assert.Contains(t, err.Error(), "Invalid raw. It must not be nil.")
    84  
    85  	_, err = csp.KeyImport([]byte{0, 1, 2, 3, 4}, nil)
    86  	assert.Error(t, err)
    87  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
    88  
    89  	_, err = csp.KeyImport([]byte{0, 1, 2, 3, 4}, &mocks.KeyImportOpts{})
    90  	assert.Error(t, err)
    91  	assert.Contains(t, err.Error(), "Unsupported 'KeyImportOpts' provided [")
    92  }
    93  
    94  func TestGetKeyInvalidInputs(t *testing.T) {
    95  	// Init a BCCSP instance with a key store that returns an error on get
    96  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{GetKeyErr: errors.New("cannot get key")})
    97  	assert.NoError(t, err)
    98  
    99  	_, err = csp.GetKey(nil)
   100  	assert.Error(t, err)
   101  	assert.Contains(t, err.Error(), "cannot get key")
   102  
   103  	// Init a BCCSP instance with a key store that returns a given key
   104  	k := &mocks.MockKey{}
   105  	csp, err = NewWithParams(256, "SHA2", &mocks.KeyStore{GetKeyValue: k})
   106  	assert.NoError(t, err)
   107  	// No SKI is needed here
   108  	k2, err := csp.GetKey(nil)
   109  	assert.NoError(t, err)
   110  	assert.Equal(t, k, k2, "Keys must be the same.")
   111  }
   112  
   113  func TestSignInvalidInputs(t *testing.T) {
   114  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   115  	assert.NoError(t, err)
   116  
   117  	_, err = csp.Sign(nil, []byte{1, 2, 3, 5}, nil)
   118  	assert.Error(t, err)
   119  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   120  
   121  	_, err = csp.Sign(&mocks.MockKey{}, nil, nil)
   122  	assert.Error(t, err)
   123  	assert.Contains(t, err.Error(), "Invalid digest. Cannot be empty.")
   124  
   125  	_, err = csp.Sign(&mocks.MockKey{}, []byte{1, 2, 3, 5}, nil)
   126  	assert.Error(t, err)
   127  	assert.Contains(t, err.Error(), "Unsupported 'SignKey' provided [")
   128  }
   129  
   130  func TestVerifyInvalidInputs(t *testing.T) {
   131  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   132  	assert.NoError(t, err)
   133  
   134  	_, err = csp.Verify(nil, []byte{1, 2, 3, 5}, []byte{1, 2, 3, 5}, nil)
   135  	assert.Error(t, err)
   136  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   137  
   138  	_, err = csp.Verify(&mocks.MockKey{}, nil, []byte{1, 2, 3, 5}, nil)
   139  	assert.Error(t, err)
   140  	assert.Contains(t, err.Error(), "Invalid signature. Cannot be empty.")
   141  
   142  	_, err = csp.Verify(&mocks.MockKey{}, []byte{1, 2, 3, 5}, nil, nil)
   143  	assert.Error(t, err)
   144  	assert.Contains(t, err.Error(), "Invalid digest. Cannot be empty.")
   145  
   146  	_, err = csp.Verify(&mocks.MockKey{}, []byte{1, 2, 3, 5}, []byte{1, 2, 3, 5}, nil)
   147  	assert.Error(t, err)
   148  	assert.Contains(t, err.Error(), "Unsupported 'VerifyKey' provided [")
   149  }
   150  
   151  func TestEncryptInvalidInputs(t *testing.T) {
   152  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   153  	assert.NoError(t, err)
   154  
   155  	_, err = csp.Encrypt(nil, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   156  	assert.Error(t, err)
   157  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   158  
   159  	_, err = csp.Encrypt(&mocks.MockKey{}, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   160  	assert.Error(t, err)
   161  	assert.Contains(t, err.Error(), "Unsupported 'EncryptKey' provided [")
   162  }
   163  
   164  func TestDecryptInvalidInputs(t *testing.T) {
   165  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   166  	assert.NoError(t, err)
   167  
   168  	_, err = csp.Decrypt(nil, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   169  	assert.Error(t, err)
   170  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   171  
   172  	_, err = csp.Decrypt(&mocks.MockKey{}, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   173  	assert.Error(t, err)
   174  	assert.Contains(t, err.Error(), "Unsupported 'DecryptKey' provided [")
   175  }
   176  
   177  func TestHashInvalidInputs(t *testing.T) {
   178  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   179  	assert.NoError(t, err)
   180  
   181  	_, err = csp.Hash(nil, nil)
   182  	assert.Error(t, err)
   183  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
   184  
   185  	_, err = csp.Hash(nil, &mocks.HashOpts{})
   186  	assert.Error(t, err)
   187  	assert.Contains(t, err.Error(), "Unsupported 'HashOpt' provided [")
   188  }
   189  
   190  func TestGetHashInvalidInputs(t *testing.T) {
   191  	csp, err := NewWithParams(256, "SHA2", &mocks.KeyStore{})
   192  	assert.NoError(t, err)
   193  
   194  	_, err = csp.GetHash(nil)
   195  	assert.Error(t, err)
   196  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
   197  
   198  	_, err = csp.GetHash(&mocks.HashOpts{})
   199  	assert.Error(t, err)
   200  	assert.Contains(t, err.Error(), "Unsupported 'HashOpt' provided [")
   201  }