github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/p2p/crypto/key_test.go (about)

     1  package crypto_test
     2  
     3  import (
     4  	. "github.com/ipfs/go-ipfs/p2p/crypto"
     5  
     6  	"bytes"
     7  	tu "github.com/ipfs/go-ipfs/util/testutil"
     8  	"testing"
     9  )
    10  
    11  func TestRsaKeys(t *testing.T) {
    12  	sk, pk, err := tu.RandTestKeyPair(512)
    13  	if err != nil {
    14  		t.Fatal(err)
    15  	}
    16  	testKeySignature(t, sk)
    17  	testKeyEncoding(t, sk)
    18  	testKeyEquals(t, sk)
    19  	testKeyEquals(t, pk)
    20  }
    21  
    22  func testKeySignature(t *testing.T, sk PrivKey) {
    23  	pk := sk.GetPublic()
    24  
    25  	text := sk.GenSecret()
    26  	sig, err := sk.Sign(text)
    27  	if err != nil {
    28  		t.Fatal(err)
    29  	}
    30  
    31  	valid, err := pk.Verify(text, sig)
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  
    36  	if !valid {
    37  		t.Fatal("Invalid signature.")
    38  	}
    39  }
    40  
    41  func testKeyEncoding(t *testing.T, sk PrivKey) {
    42  	skbm, err := MarshalPrivateKey(sk)
    43  	if err != nil {
    44  		t.Fatal(err)
    45  	}
    46  
    47  	sk2, err := UnmarshalPrivateKey(skbm)
    48  	if err != nil {
    49  		t.Fatal(err)
    50  	}
    51  
    52  	skbm2, err := MarshalPrivateKey(sk2)
    53  	if err != nil {
    54  		t.Fatal(err)
    55  	}
    56  
    57  	if !bytes.Equal(skbm, skbm2) {
    58  		t.Error("skb -> marshal -> unmarshal -> skb failed.\n", skbm, "\n", skbm2)
    59  	}
    60  
    61  	pk := sk.GetPublic()
    62  	pkbm, err := MarshalPublicKey(pk)
    63  	if err != nil {
    64  		t.Fatal(err)
    65  	}
    66  
    67  	_, err = UnmarshalPublicKey(pkbm)
    68  	if err != nil {
    69  		t.Fatal(err)
    70  	}
    71  
    72  	pkbm2, err := MarshalPublicKey(pk)
    73  	if err != nil {
    74  		t.Fatal(err)
    75  	}
    76  
    77  	if !bytes.Equal(pkbm, pkbm2) {
    78  		t.Error("skb -> marshal -> unmarshal -> skb failed.\n", pkbm, "\n", pkbm2)
    79  	}
    80  }
    81  
    82  func testKeyEquals(t *testing.T, k Key) {
    83  	kb, err := k.Bytes()
    84  	if err != nil {
    85  		t.Fatal(err)
    86  	}
    87  
    88  	if !KeyEqual(k, k) {
    89  		t.Fatal("Key not equal to itself.")
    90  	}
    91  
    92  	if !KeyEqual(k, testkey(kb)) {
    93  		t.Fatal("Key not equal to key with same bytes.")
    94  	}
    95  
    96  	sk, pk, err := tu.RandTestKeyPair(512)
    97  	if err != nil {
    98  		t.Fatal(err)
    99  	}
   100  
   101  	if KeyEqual(k, sk) {
   102  		t.Fatal("Keys should not equal.")
   103  	}
   104  
   105  	if KeyEqual(k, pk) {
   106  		t.Fatal("Keys should not equal.")
   107  	}
   108  }
   109  
   110  type testkey []byte
   111  
   112  func (pk testkey) Bytes() ([]byte, error) {
   113  	return pk, nil
   114  }
   115  
   116  func (pk testkey) Equals(k Key) bool {
   117  	return KeyEqual(pk, k)
   118  }
   119  
   120  func (pk testkey) Hash() ([]byte, error) {
   121  	return KeyHash(pk)
   122  }