github.com/jonasnick/go-ethereum@v0.7.12-0.20150216215225-22176f05d387/crypto/secp256k1/secp256_test.go (about)

     1  package secp256k1
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"log"
     7  	"testing"
     8  
     9  	"github.com/jonasnick/go-ethereum/crypto/randentropy"
    10  )
    11  
    12  const TESTS = 10000 // how many tests
    13  const SigSize = 65  //64+1
    14  
    15  func Test_Secp256_00(t *testing.T) {
    16  
    17  	var nonce []byte = randentropy.GetEntropyMixed(32) //going to get bitcoins stolen!
    18  
    19  	if len(nonce) != 32 {
    20  		t.Fatal()
    21  	}
    22  
    23  }
    24  
    25  //tests for Malleability
    26  //highest bit of S must be 0; 32nd byte
    27  func CompactSigTest(sig []byte) {
    28  
    29  	var b int = int(sig[32])
    30  	if b < 0 {
    31  		log.Panic()
    32  	}
    33  	if ((b >> 7) == 1) != ((b & 0x80) == 0x80) {
    34  		log.Panic("b= %v b2= %v \n", b, b>>7)
    35  	}
    36  	if (b & 0x80) == 0x80 {
    37  		log.Panic("b= %v b2= %v \n", b, b&0x80)
    38  	}
    39  }
    40  
    41  //test pubkey/private generation
    42  func Test_Secp256_01(t *testing.T) {
    43  	pubkey, seckey := GenerateKeyPair()
    44  	if err := VerifySeckeyValidity(seckey); err != nil {
    45  		t.Fatal()
    46  	}
    47  	if err := VerifyPubkeyValidity(pubkey); err != nil {
    48  		t.Fatal()
    49  	}
    50  }
    51  
    52  //test size of messages
    53  func Test_Secp256_02s(t *testing.T) {
    54  	pubkey, seckey := GenerateKeyPair()
    55  	msg := randentropy.GetEntropyMixed(32)
    56  	sig, _ := Sign(msg, seckey)
    57  	CompactSigTest(sig)
    58  	if sig == nil {
    59  		t.Fatal("Signature nil")
    60  	}
    61  	if len(pubkey) != 65 {
    62  		t.Fail()
    63  	}
    64  	if len(seckey) != 32 {
    65  		t.Fail()
    66  	}
    67  	if len(sig) != 64+1 {
    68  		t.Fail()
    69  	}
    70  	if int(sig[64]) > 4 {
    71  		t.Fail()
    72  	} //should be 0 to 4
    73  }
    74  
    75  //test signing message
    76  func Test_Secp256_02(t *testing.T) {
    77  	pubkey1, seckey := GenerateKeyPair()
    78  	msg := randentropy.GetEntropyMixed(32)
    79  	sig, _ := Sign(msg, seckey)
    80  	if sig == nil {
    81  		t.Fatal("Signature nil")
    82  	}
    83  
    84  	pubkey2, _ := RecoverPubkey(msg, sig)
    85  	if pubkey2 == nil {
    86  		t.Fatal("Recovered pubkey invalid")
    87  	}
    88  	if bytes.Equal(pubkey1, pubkey2) == false {
    89  		t.Fatal("Recovered pubkey does not match")
    90  	}
    91  
    92  	err := VerifySignature(msg, sig, pubkey1)
    93  	if err != nil {
    94  		t.Fatal("Signature invalid")
    95  	}
    96  }
    97  
    98  //test pubkey recovery
    99  func Test_Secp256_02a(t *testing.T) {
   100  	pubkey1, seckey1 := GenerateKeyPair()
   101  	msg := randentropy.GetEntropyMixed(32)
   102  	sig, _ := Sign(msg, seckey1)
   103  
   104  	if sig == nil {
   105  		t.Fatal("Signature nil")
   106  	}
   107  	err := VerifySignature(msg, sig, pubkey1)
   108  	if err != nil {
   109  		t.Fatal("Signature invalid")
   110  	}
   111  
   112  	pubkey2, _ := RecoverPubkey(msg, sig)
   113  	if len(pubkey1) != len(pubkey2) {
   114  		t.Fatal()
   115  	}
   116  	for i, _ := range pubkey1 {
   117  		if pubkey1[i] != pubkey2[i] {
   118  			t.Fatal()
   119  		}
   120  	}
   121  	if bytes.Equal(pubkey1, pubkey2) == false {
   122  		t.Fatal()
   123  	}
   124  }
   125  
   126  //test random messages for the same pub/private key
   127  func Test_Secp256_03(t *testing.T) {
   128  	_, seckey := GenerateKeyPair()
   129  	for i := 0; i < TESTS; i++ {
   130  		msg := randentropy.GetEntropyMixed(32)
   131  		sig, _ := Sign(msg, seckey)
   132  		CompactSigTest(sig)
   133  
   134  		sig[len(sig)-1] %= 4
   135  		pubkey2, _ := RecoverPubkey(msg, sig)
   136  		if pubkey2 == nil {
   137  			t.Fail()
   138  		}
   139  	}
   140  }
   141  
   142  //test random messages for different pub/private keys
   143  func Test_Secp256_04(t *testing.T) {
   144  	for i := 0; i < TESTS; i++ {
   145  		pubkey1, seckey := GenerateKeyPair()
   146  		msg := randentropy.GetEntropyMixed(32)
   147  		sig, _ := Sign(msg, seckey)
   148  		CompactSigTest(sig)
   149  
   150  		if sig[len(sig)-1] >= 4 {
   151  			t.Fail()
   152  		}
   153  		pubkey2, _ := RecoverPubkey(msg, sig)
   154  		if pubkey2 == nil {
   155  			t.Fail()
   156  		}
   157  		if bytes.Equal(pubkey1, pubkey2) == false {
   158  			t.Fail()
   159  		}
   160  	}
   161  }
   162  
   163  //test random signatures against fixed messages; should fail
   164  
   165  //crashes:
   166  //	-SIPA look at this
   167  
   168  func randSig() []byte {
   169  	sig := randentropy.GetEntropyMixed(65)
   170  	sig[32] &= 0x70
   171  	sig[64] %= 4
   172  	return sig
   173  }
   174  
   175  func Test_Secp256_06a_alt0(t *testing.T) {
   176  	pubkey1, seckey := GenerateKeyPair()
   177  	msg := randentropy.GetEntropyMixed(32)
   178  	sig, _ := Sign(msg, seckey)
   179  
   180  	if sig == nil {
   181  		t.Fail()
   182  	}
   183  	if len(sig) != 65 {
   184  		t.Fail()
   185  	}
   186  	for i := 0; i < TESTS; i++ {
   187  		sig = randSig()
   188  		pubkey2, _ := RecoverPubkey(msg, sig)
   189  
   190  		if bytes.Equal(pubkey1, pubkey2) == true {
   191  			t.Fail()
   192  		}
   193  
   194  		if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil {
   195  			t.Fail()
   196  		}
   197  
   198  		if VerifySignature(msg, sig, pubkey1) == nil {
   199  			t.Fail()
   200  		}
   201  	}
   202  }
   203  
   204  //test random messages against valid signature: should fail
   205  
   206  func Test_Secp256_06b(t *testing.T) {
   207  	pubkey1, seckey := GenerateKeyPair()
   208  	msg := randentropy.GetEntropyMixed(32)
   209  	sig, _ := Sign(msg, seckey)
   210  
   211  	fail_count := 0
   212  	for i := 0; i < TESTS; i++ {
   213  		msg = randentropy.GetEntropyMixed(32)
   214  		pubkey2, _ := RecoverPubkey(msg, sig)
   215  		if bytes.Equal(pubkey1, pubkey2) == true {
   216  			t.Fail()
   217  		}
   218  
   219  		if pubkey2 != nil && VerifySignature(msg, sig, pubkey2) != nil {
   220  			t.Fail()
   221  		}
   222  
   223  		if VerifySignature(msg, sig, pubkey1) == nil {
   224  			t.Fail()
   225  		}
   226  	}
   227  	if fail_count != 0 {
   228  		fmt.Printf("ERROR: Accepted signature for %v of %v random messages\n", fail_count, TESTS)
   229  	}
   230  }
   231  
   232  func TestInvalidKey(t *testing.T) {
   233  	p1 := make([]byte, 32)
   234  	err := VerifySeckeyValidity(p1)
   235  	if err == nil {
   236  		t.Errorf("pvk %x varify sec key should have returned error", p1)
   237  	}
   238  }