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  }