github.com/kaituanwang/hyperledger@v2.0.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 }