github.com/adnan-c/fabric_e2e_couchdb@v0.6.1-preview.0.20170228180935-21ce6b23cf91/accesscontrol/crypto/ecdsa/ecdsa_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2016 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 ecdsa
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/hyperledger/fabric/accesscontrol/crypto/utils"
    23  	"github.com/hyperledger/fabric/core/crypto/primitives"
    24  )
    25  
    26  func TestSignatureVerifier(t *testing.T) {
    27  	// Create a signature
    28  	primitives.SetSecurityLevel("SHA3", 256)
    29  
    30  	cert, key, err := utils.NewSelfSignedCert()
    31  	if err != nil {
    32  		t.Fatal(err)
    33  	}
    34  
    35  	message := []byte("Hello World!")
    36  	signature, err := utils.ECDSASign(key, message)
    37  	if err != nil {
    38  		t.Fatal(err)
    39  	}
    40  
    41  	// Instantiate a new SignatureVerifier
    42  	sv := NewX509ECDSASignatureVerifier()
    43  
    44  	// Verify the signature
    45  	ok, err := sv.Verify(cert, signature, message)
    46  	if err != nil {
    47  		t.Fatal(err)
    48  	}
    49  	if !ok {
    50  		t.Fatal("Signature does not verify")
    51  	}
    52  }
    53  
    54  func TestSignatureVerifierSHA2(t *testing.T) {
    55  	// Create a signature
    56  	primitives.SetSecurityLevel("SHA2", 256)
    57  
    58  	cert, key, err := utils.NewSelfSignedCert()
    59  	if err != nil {
    60  		t.Fatal(err)
    61  	}
    62  
    63  	message := []byte("Hello World!")
    64  	signature, err := utils.ECDSASign(key, message)
    65  	if err != nil {
    66  		t.Fatal(err)
    67  	}
    68  
    69  	// Instantiate a new SignatureVerifier
    70  	sv := NewX509ECDSASignatureVerifier()
    71  
    72  	// Verify the signature
    73  	ok, err := sv.Verify(cert, signature, message)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  	if !ok {
    78  		t.Fatal("Signature does not verify")
    79  	}
    80  }
    81  
    82  func TestSignatureVerifierSHA2_384(t *testing.T) {
    83  	// Create a signature
    84  	primitives.SetSecurityLevel("SHA2", 384)
    85  
    86  	cert, key, err := utils.NewSelfSignedCert()
    87  	if err != nil {
    88  		t.Fatal(err)
    89  	}
    90  
    91  	message := []byte("Hello World!")
    92  	signature, err := utils.ECDSASign(key, message)
    93  	if err != nil {
    94  		t.Fatal(err)
    95  	}
    96  
    97  	// Instantiate a new SignatureVerifier
    98  	sv := NewX509ECDSASignatureVerifier()
    99  
   100  	// Verify the signature
   101  	ok, err := sv.Verify(cert, signature, message)
   102  	if err != nil {
   103  		t.Fatal(err)
   104  	}
   105  	if !ok {
   106  		t.Fatal("Signature does not verify")
   107  	}
   108  }
   109  
   110  func TestSignatureVerifierSHA3_384(t *testing.T) {
   111  	// Create a signature
   112  	primitives.SetSecurityLevel("SHA3", 384)
   113  
   114  	cert, key, err := utils.NewSelfSignedCert()
   115  	if err != nil {
   116  		t.Fatal(err)
   117  	}
   118  
   119  	message := []byte("Hello World!")
   120  	signature, err := utils.ECDSASign(key, message)
   121  	if err != nil {
   122  		t.Fatal(err)
   123  	}
   124  
   125  	// Instantiate a new SignatureVerifier
   126  	sv := NewX509ECDSASignatureVerifier()
   127  
   128  	// Verify the signature
   129  	ok, err := sv.Verify(cert, signature, message)
   130  	if err != nil {
   131  		t.Fatal(err)
   132  	}
   133  	if !ok {
   134  		t.Fatal("Signature does not verify")
   135  	}
   136  }
   137  
   138  func TestSignatureVerifierSHA2_512(t *testing.T) {
   139  	// Create a signature
   140  	primitives.SetSecurityLevel("SHA2", 512)
   141  
   142  	cert, key, err := utils.NewSelfSignedCert()
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  
   147  	message := []byte("Hello World!")
   148  	signature, err := utils.ECDSASign(key, message)
   149  	if err != nil {
   150  		t.Fatal(err)
   151  	}
   152  
   153  	// Instantiate a new SignatureVerifier
   154  	sv := NewX509ECDSASignatureVerifier()
   155  
   156  	// Verify the signature
   157  	ok, err := sv.Verify(cert, signature, message)
   158  	if err != nil {
   159  		t.Fatal(err)
   160  	}
   161  	if !ok {
   162  		t.Fatal("Signature does not verify")
   163  	}
   164  }
   165  
   166  func TestSignatureVerifierSHA3_512(t *testing.T) {
   167  	// Create a signature
   168  	primitives.SetSecurityLevel("SHA3", 512)
   169  
   170  	cert, key, err := utils.NewSelfSignedCert()
   171  	if err != nil {
   172  		t.Fatal(err)
   173  	}
   174  
   175  	message := []byte("Hello World!")
   176  	signature, err := utils.ECDSASign(key, message)
   177  	if err != nil {
   178  		t.Fatal(err)
   179  	}
   180  
   181  	// Instantiate a new SignatureVerifier
   182  	sv := NewX509ECDSASignatureVerifier()
   183  
   184  	// Verify the signature
   185  	ok, err := sv.Verify(cert, signature, message)
   186  	if err != nil {
   187  		t.Fatal(err)
   188  	}
   189  	if !ok {
   190  		t.Fatal("Signature does not verify")
   191  	}
   192  }