vendor/github.com/libp2p/go-libp2p-crypto/key_test.go

   1 package crypto_test
   2
   3 import (
   4         "bytes"
   5         "crypto/rand"
   6         "testing"
   7
   8         . "github.com/libp2p/go-libp2p-crypto"
   9         pb "github.com/libp2p/go-libp2p-crypto/pb"
  10         tu "github.com/libp2p/go-libp2p-crypto/test"
  11 )
  12
  13 func TestKeys(t *testing.T) {
  14         for _, typ := range KeyTypes {
  15                 testKeyType(typ, t)
  16         }
  17 }
  18
  19 func testKeyType(typ int, t *testing.T) {
  20         sk, pk, err := tu.RandTestKeyPair(typ, 512)
  21         if err != nil {
  22                 t.Fatal(err)
  23         }
  24
  25         testKeySignature(t, sk)
  26         testKeyEncoding(t, sk)
  27         testKeyEquals(t, sk)
  28         testKeyEquals(t, pk)
  29 }
  30
  31 func testKeySignature(t *testing.T, sk PrivKey) {
  32         pk := sk.GetPublic()
  33
  34         text := make([]byte, 16)
  35         if _, err := rand.Read(text); err != nil {
  36                 t.Fatal(err)
  37         }
  38
  39         sig, err := sk.Sign(text)
  40         if err != nil {
  41                 t.Fatal(err)
  42         }
  43
  44         valid, err := pk.Verify(text, sig)
  45         if err != nil {
  46                 t.Fatal(err)
  47         }
  48
  49         if !valid {
  50                 t.Fatal("Invalid signature.")
  51         }
  52 }
  53
  54 func testKeyEncoding(t *testing.T, sk PrivKey) {
  55         skbm, err := MarshalPrivateKey(sk)
  56         if err != nil {
  57                 t.Fatal(err)
  58         }
  59
  60         sk2, err := UnmarshalPrivateKey(skbm)
  61         if err != nil {
  62                 t.Fatal(err)
  63         }
  64
  65         if !sk.Equals(sk2) {
  66                 t.Error("Unmarshaled private key didn't match original.\n")
  67         }
  68
  69         skbm2, err := MarshalPrivateKey(sk2)
  70         if err != nil {
  71                 t.Fatal(err)
  72         }
  73
  74         if !bytes.Equal(skbm, skbm2) {
  75                 t.Error("skb -> marshal -> unmarshal -> skb failed.\n", skbm, "\n", skbm2)
  76         }
  77
  78         pk := sk.GetPublic()
  79         pkbm, err := MarshalPublicKey(pk)
  80         if err != nil {
  81                 t.Fatal(err)
  82         }
  83
  84         pk2, err := UnmarshalPublicKey(pkbm)
  85         if err != nil {
  86                 t.Fatal(err)
  87         }
  88
  89         if !pk.Equals(pk2) {
  90                 t.Error("Unmarshaled public key didn't match original.\n")
  91         }
  92
  93         pkbm2, err := MarshalPublicKey(pk)
  94         if err != nil {
  95                 t.Fatal(err)
  96         }
  97
  98         if !bytes.Equal(pkbm, pkbm2) {
  99                 t.Error("skb -> marshal -> unmarshal -> skb failed.\n", pkbm, "\n", pkbm2)
 100         }
 101 }
 102
 103 func testKeyEquals(t *testing.T, k Key) {
 104         kb, err := k.Bytes()
 105         if err != nil {
 106                 t.Fatal(err)
 107         }
 108
 109         if !KeyEqual(k, k) {
 110                 t.Fatal("Key not equal to itself.")
 111         }
 112
 113         if !KeyEqual(k, testkey(kb)) {
 114                 t.Fatal("Key not equal to key with same bytes.")
 115         }
 116
 117         sk, pk, err := tu.RandTestKeyPair(RSA, 512)
 118         if err != nil {
 119                 t.Fatal(err)
 120         }
 121
 122         if KeyEqual(k, sk) {
 123                 t.Fatal("Keys should not equal.")
 124         }
 125
 126         if KeyEqual(k, pk) {
 127                 t.Fatal("Keys should not equal.")
 128         }
 129 }
 130
 131 type testkey []byte
 132
 133 func (pk testkey) Bytes() ([]byte, error) {
 134         return pk, nil
 135 }
 136
 137 func (pk testkey) Type() pb.KeyType {
 138         return pb.KeyType_RSA
 139 }
 140
 141 func (pk testkey) Raw() ([]byte, error) {
 142         return pk, nil
 143 }
 144
 145 func (pk testkey) Equals(k Key) bool {
 146         return KeyEqual(pk, k)
 147 }