github.com/kchristidis/fabric@v1.0.4-0.20171028114726-837acd08cde1/bccsp/sw/keyimport_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 "crypto/rand" 21 "crypto/rsa" 22 "crypto/x509" 23 "errors" 24 "reflect" 25 "testing" 26 27 mocks2 "github.com/hyperledger/fabric/bccsp/mocks" 28 "github.com/hyperledger/fabric/bccsp/sw/mocks" 29 "github.com/hyperledger/fabric/bccsp/utils" 30 "github.com/stretchr/testify/assert" 31 ) 32 33 func TestKeyImport(t *testing.T) { 34 expectedRaw := []byte{1, 2, 3} 35 expectedOpts := &mocks2.KeyDerivOpts{EphemeralValue: true} 36 expectetValue := &mocks2.MockKey{BytesValue: []byte{1, 2, 3, 4, 5}} 37 expectedErr := errors.New("Expected Error") 38 39 keyImporters := make(map[reflect.Type]KeyImporter) 40 keyImporters[reflect.TypeOf(&mocks2.KeyDerivOpts{})] = &mocks.KeyImporter{ 41 RawArg: expectedRaw, 42 OptsArg: expectedOpts, 43 Value: expectetValue, 44 Err: expectedErr, 45 } 46 csp := impl{keyImporters: keyImporters} 47 value, err := csp.KeyImport(expectedRaw, expectedOpts) 48 assert.Nil(t, value) 49 assert.Contains(t, err.Error(), expectedErr.Error()) 50 51 keyImporters = make(map[reflect.Type]KeyImporter) 52 keyImporters[reflect.TypeOf(&mocks2.KeyDerivOpts{})] = &mocks.KeyImporter{ 53 RawArg: expectedRaw, 54 OptsArg: expectedOpts, 55 Value: expectetValue, 56 Err: nil, 57 } 58 csp = impl{keyImporters: keyImporters} 59 value, err = csp.KeyImport(expectedRaw, expectedOpts) 60 assert.Equal(t, expectetValue, value) 61 assert.Nil(t, err) 62 } 63 64 func TestAES256ImportKeyOptsKeyImporter(t *testing.T) { 65 ki := aes256ImportKeyOptsKeyImporter{} 66 67 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 68 assert.Error(t, err) 69 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 70 71 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 72 assert.Error(t, err) 73 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 74 75 _, err = ki.KeyImport([]byte(nil), &mocks2.KeyImportOpts{}) 76 assert.Error(t, err) 77 assert.Contains(t, err.Error(), "Invalid raw material. It must not be nil.") 78 79 _, err = ki.KeyImport([]byte{0}, &mocks2.KeyImportOpts{}) 80 assert.Error(t, err) 81 assert.Contains(t, err.Error(), "Invalid Key Length [") 82 } 83 84 func TestHMACImportKeyOptsKeyImporter(t *testing.T) { 85 ki := hmacImportKeyOptsKeyImporter{} 86 87 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 88 assert.Error(t, err) 89 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 90 91 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 92 assert.Error(t, err) 93 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 94 95 _, err = ki.KeyImport([]byte(nil), &mocks2.KeyImportOpts{}) 96 assert.Error(t, err) 97 assert.Contains(t, err.Error(), "Invalid raw material. It must not be nil.") 98 } 99 100 func TestECDSAPKIXPublicKeyImportOptsKeyImporter(t *testing.T) { 101 ki := ecdsaPKIXPublicKeyImportOptsKeyImporter{} 102 103 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 104 assert.Error(t, err) 105 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 106 107 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 108 assert.Error(t, err) 109 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 110 111 _, err = ki.KeyImport([]byte(nil), &mocks2.KeyImportOpts{}) 112 assert.Error(t, err) 113 assert.Contains(t, err.Error(), "Invalid raw. It must not be nil.") 114 115 _, err = ki.KeyImport([]byte{0}, &mocks2.KeyImportOpts{}) 116 assert.Error(t, err) 117 assert.Contains(t, err.Error(), "Failed converting PKIX to ECDSA public key [") 118 119 k, err := rsa.GenerateKey(rand.Reader, 512) 120 assert.NoError(t, err) 121 raw, err := utils.PublicKeyToDER(&k.PublicKey) 122 assert.NoError(t, err) 123 _, err = ki.KeyImport(raw, &mocks2.KeyImportOpts{}) 124 assert.Error(t, err) 125 assert.Contains(t, err.Error(), "Failed casting to ECDSA public key. Invalid raw material.") 126 } 127 128 func TestECDSAPrivateKeyImportOptsKeyImporter(t *testing.T) { 129 ki := ecdsaPrivateKeyImportOptsKeyImporter{} 130 131 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 132 assert.Error(t, err) 133 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 134 135 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 136 assert.Error(t, err) 137 assert.Contains(t, err.Error(), "Invalid raw material. Expected byte array.") 138 139 _, err = ki.KeyImport([]byte(nil), &mocks2.KeyImportOpts{}) 140 assert.Error(t, err) 141 assert.Contains(t, err.Error(), "Invalid raw. It must not be nil.") 142 143 _, err = ki.KeyImport([]byte{0}, &mocks2.KeyImportOpts{}) 144 assert.Error(t, err) 145 assert.Contains(t, err.Error(), "Failed converting PKIX to ECDSA public key") 146 147 k, err := rsa.GenerateKey(rand.Reader, 512) 148 assert.NoError(t, err) 149 raw := x509.MarshalPKCS1PrivateKey(k) 150 _, err = ki.KeyImport(raw, &mocks2.KeyImportOpts{}) 151 assert.Error(t, err) 152 assert.Contains(t, err.Error(), "Failed casting to ECDSA private key. Invalid raw material.") 153 } 154 155 func TestECDSAGoPublicKeyImportOptsKeyImporter(t *testing.T) { 156 ki := ecdsaGoPublicKeyImportOptsKeyImporter{} 157 158 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 159 assert.Error(t, err) 160 assert.Contains(t, err.Error(), "Invalid raw material. Expected *ecdsa.PublicKey.") 161 162 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 163 assert.Error(t, err) 164 assert.Contains(t, err.Error(), "Invalid raw material. Expected *ecdsa.PublicKey.") 165 } 166 167 func TestRSAGoPublicKeyImportOptsKeyImporter(t *testing.T) { 168 ki := rsaGoPublicKeyImportOptsKeyImporter{} 169 170 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 171 assert.Error(t, err) 172 assert.Contains(t, err.Error(), "Invalid raw material. Expected *rsa.PublicKey.") 173 174 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 175 assert.Error(t, err) 176 assert.Contains(t, err.Error(), "Invalid raw material. Expected *rsa.PublicKey.") 177 } 178 179 func TestX509PublicKeyImportOptsKeyImporter(t *testing.T) { 180 ki := x509PublicKeyImportOptsKeyImporter{} 181 182 _, err := ki.KeyImport("Hello World", &mocks2.KeyImportOpts{}) 183 assert.Error(t, err) 184 assert.Contains(t, err.Error(), "Invalid raw material. Expected *x509.Certificate.") 185 186 _, err = ki.KeyImport(nil, &mocks2.KeyImportOpts{}) 187 assert.Error(t, err) 188 assert.Contains(t, err.Error(), "Invalid raw material. Expected *x509.Certificate.") 189 190 cert := &x509.Certificate{} 191 cert.PublicKey = "Hello world" 192 _, err = ki.KeyImport(cert, &mocks2.KeyImportOpts{}) 193 assert.Error(t, err) 194 assert.Contains(t, err.Error(), "Certificate's public key type not recognized. Supported keys: [ECDSA, RSA]") 195 }