github.com/kchristidis/fabric@v1.0.4-0.20171028114726-837acd08cde1/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  	"testing"
    22  
    23  	"reflect"
    24  
    25  	"github.com/hyperledger/fabric/bccsp"
    26  	"github.com/hyperledger/fabric/bccsp/mocks"
    27  	mocks2 "github.com/hyperledger/fabric/bccsp/sw/mocks"
    28  	"github.com/stretchr/testify/assert"
    29  )
    30  
    31  func TestKeyGenInvalidInputs(t *testing.T) {
    32  	// Init a BCCSP instance with a key store that returns an error on store
    33  	csp, err := New(256, "SHA2", &mocks.KeyStore{StoreKeyErr: errors.New("cannot store key")})
    34  	assert.NoError(t, err)
    35  
    36  	_, err = csp.KeyGen(nil)
    37  	assert.Error(t, err)
    38  	assert.Contains(t, err.Error(), "Invalid Opts parameter. It must not be nil.")
    39  
    40  	_, err = csp.KeyGen(&mocks.KeyGenOpts{})
    41  	assert.Error(t, err)
    42  	assert.Contains(t, err.Error(), "Unsupported 'KeyGenOpts' provided [")
    43  
    44  	_, err = csp.KeyGen(&bccsp.ECDSAP256KeyGenOpts{})
    45  	assert.Error(t, err, "Generation of a non-ephemeral key must fail. KeyStore is programmed to fail.")
    46  	assert.Contains(t, err.Error(), "cannot store key")
    47  }
    48  
    49  func TestKeyDerivInvalidInputs(t *testing.T) {
    50  	csp, err := New(256, "SHA2", &mocks.KeyStore{StoreKeyErr: errors.New("cannot store key")})
    51  	assert.NoError(t, err)
    52  
    53  	_, err = csp.KeyDeriv(nil, &bccsp.ECDSAReRandKeyOpts{})
    54  	assert.Error(t, err)
    55  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
    56  
    57  	_, err = csp.KeyDeriv(&mocks.MockKey{}, nil)
    58  	assert.Error(t, err)
    59  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
    60  
    61  	_, err = csp.KeyDeriv(&mocks.MockKey{}, &bccsp.ECDSAReRandKeyOpts{})
    62  	assert.Error(t, err)
    63  	assert.Contains(t, err.Error(), "Unsupported 'Key' provided [")
    64  
    65  	keyDerivers := make(map[reflect.Type]KeyDeriver)
    66  	keyDerivers[reflect.TypeOf(&mocks.MockKey{})] = &mocks2.KeyDeriver{
    67  		KeyArg:  &mocks.MockKey{},
    68  		OptsArg: &mocks.KeyDerivOpts{EphemeralValue: false},
    69  		Value:   nil,
    70  		Err:     nil,
    71  	}
    72  	csp.(*impl).keyDerivers = keyDerivers
    73  	_, err = csp.KeyDeriv(&mocks.MockKey{}, &mocks.KeyDerivOpts{EphemeralValue: false})
    74  	assert.Error(t, err, "KeyDerivation of a non-ephemeral key must fail. KeyStore is programmed to fail.")
    75  	assert.Contains(t, err.Error(), "cannot store key")
    76  }
    77  
    78  func TestKeyImportInvalidInputs(t *testing.T) {
    79  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
    80  	assert.NoError(t, err)
    81  
    82  	_, err = csp.KeyImport(nil, &bccsp.AES256ImportKeyOpts{})
    83  	assert.Error(t, err)
    84  	assert.Contains(t, err.Error(), "Invalid raw. It must not be nil.")
    85  
    86  	_, err = csp.KeyImport([]byte{0, 1, 2, 3, 4}, nil)
    87  	assert.Error(t, err)
    88  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
    89  
    90  	_, err = csp.KeyImport([]byte{0, 1, 2, 3, 4}, &mocks.KeyImportOpts{})
    91  	assert.Error(t, err)
    92  	assert.Contains(t, err.Error(), "Unsupported 'KeyImportOpts' provided [")
    93  }
    94  
    95  func TestGetKeyInvalidInputs(t *testing.T) {
    96  	// Init a BCCSP instance with a key store that returns an error on get
    97  	csp, err := New(256, "SHA2", &mocks.KeyStore{GetKeyErr: errors.New("cannot get key")})
    98  	assert.NoError(t, err)
    99  
   100  	_, err = csp.GetKey(nil)
   101  	assert.Error(t, err)
   102  	assert.Contains(t, err.Error(), "cannot get key")
   103  
   104  	// Init a BCCSP instance with a key store that returns a given key
   105  	k := &mocks.MockKey{}
   106  	csp, err = New(256, "SHA2", &mocks.KeyStore{GetKeyValue: k})
   107  	assert.NoError(t, err)
   108  	// No SKI is needed here
   109  	k2, err := csp.GetKey(nil)
   110  	assert.NoError(t, err)
   111  	assert.Equal(t, k, k2, "Keys must be the same.")
   112  }
   113  
   114  func TestSignInvalidInputs(t *testing.T) {
   115  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   116  	assert.NoError(t, err)
   117  
   118  	_, err = csp.Sign(nil, []byte{1, 2, 3, 5}, nil)
   119  	assert.Error(t, err)
   120  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   121  
   122  	_, err = csp.Sign(&mocks.MockKey{}, nil, nil)
   123  	assert.Error(t, err)
   124  	assert.Contains(t, err.Error(), "Invalid digest. Cannot be empty.")
   125  
   126  	_, err = csp.Sign(&mocks.MockKey{}, []byte{1, 2, 3, 5}, nil)
   127  	assert.Error(t, err)
   128  	assert.Contains(t, err.Error(), "Unsupported 'SignKey' provided [")
   129  }
   130  
   131  func TestVerifyInvalidInputs(t *testing.T) {
   132  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   133  	assert.NoError(t, err)
   134  
   135  	_, err = csp.Verify(nil, []byte{1, 2, 3, 5}, []byte{1, 2, 3, 5}, nil)
   136  	assert.Error(t, err)
   137  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   138  
   139  	_, err = csp.Verify(&mocks.MockKey{}, nil, []byte{1, 2, 3, 5}, nil)
   140  	assert.Error(t, err)
   141  	assert.Contains(t, err.Error(), "Invalid signature. Cannot be empty.")
   142  
   143  	_, err = csp.Verify(&mocks.MockKey{}, []byte{1, 2, 3, 5}, nil, nil)
   144  	assert.Error(t, err)
   145  	assert.Contains(t, err.Error(), "Invalid digest. Cannot be empty.")
   146  
   147  	_, err = csp.Verify(&mocks.MockKey{}, []byte{1, 2, 3, 5}, []byte{1, 2, 3, 5}, nil)
   148  	assert.Error(t, err)
   149  	assert.Contains(t, err.Error(), "Unsupported 'VerifyKey' provided [")
   150  }
   151  
   152  func TestEncryptInvalidInputs(t *testing.T) {
   153  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   154  	assert.NoError(t, err)
   155  
   156  	_, err = csp.Encrypt(nil, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   157  	assert.Error(t, err)
   158  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   159  
   160  	_, err = csp.Encrypt(&mocks.MockKey{}, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   161  	assert.Error(t, err)
   162  	assert.Contains(t, err.Error(), "Unsupported 'EncryptKey' provided [")
   163  }
   164  
   165  func TestDecryptInvalidInputs(t *testing.T) {
   166  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   167  	assert.NoError(t, err)
   168  
   169  	_, err = csp.Decrypt(nil, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   170  	assert.Error(t, err)
   171  	assert.Contains(t, err.Error(), "Invalid Key. It must not be nil.")
   172  
   173  	_, err = csp.Decrypt(&mocks.MockKey{}, []byte{1, 2, 3, 4}, &bccsp.AESCBCPKCS7ModeOpts{})
   174  	assert.Error(t, err)
   175  	assert.Contains(t, err.Error(), "Unsupported 'DecryptKey' provided [")
   176  }
   177  
   178  func TestHashInvalidInputs(t *testing.T) {
   179  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   180  	assert.NoError(t, err)
   181  
   182  	_, err = csp.Hash(nil, nil)
   183  	assert.Error(t, err)
   184  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
   185  
   186  	_, err = csp.Hash(nil, &mocks.HashOpts{})
   187  	assert.Error(t, err)
   188  	assert.Contains(t, err.Error(), "Unsupported 'HashOpt' provided [")
   189  }
   190  
   191  func TestGetHashInvalidInputs(t *testing.T) {
   192  	csp, err := New(256, "SHA2", &mocks.KeyStore{})
   193  	assert.NoError(t, err)
   194  
   195  	_, err = csp.GetHash(nil)
   196  	assert.Error(t, err)
   197  	assert.Contains(t, err.Error(), "Invalid opts. It must not be nil.")
   198  
   199  	_, err = csp.GetHash(&mocks.HashOpts{})
   200  	assert.Error(t, err)
   201  	assert.Contains(t, err.Error(), "Unsupported 'HashOpt' provided [")
   202  }