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 }