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  }