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