github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/p2p/test/util/key.go (about)

     1  package testutil
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"testing"
     7  
     8  	eventlog "github.com/ipfs/go-ipfs/thirdparty/eventlog"
     9  	u "github.com/ipfs/go-ipfs/util"
    10  	testutil "github.com/ipfs/go-ipfs/util/testutil"
    11  
    12  	ic "github.com/ipfs/go-ipfs/p2p/crypto"
    13  	peer "github.com/ipfs/go-ipfs/p2p/peer"
    14  
    15  	ma "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
    16  )
    17  
    18  var log = eventlog.Logger("boguskey")
    19  
    20  // TestBogusPrivateKey is a key used for testing (to avoid expensive keygen)
    21  type TestBogusPrivateKey []byte
    22  
    23  // TestBogusPublicKey is a key used for testing (to avoid expensive keygen)
    24  type TestBogusPublicKey []byte
    25  
    26  func (pk TestBogusPublicKey) Verify(data, sig []byte) (bool, error) {
    27  	log.Errorf("TestBogusPublicKey.Verify -- this better be a test!")
    28  	return bytes.Equal(data, reverse(sig)), nil
    29  }
    30  
    31  func (pk TestBogusPublicKey) Bytes() ([]byte, error) {
    32  	return []byte(pk), nil
    33  }
    34  
    35  func (pk TestBogusPublicKey) Encrypt(b []byte) ([]byte, error) {
    36  	log.Errorf("TestBogusPublicKey.Encrypt -- this better be a test!")
    37  	return reverse(b), nil
    38  }
    39  
    40  // Equals checks whether this key is equal to another
    41  func (pk TestBogusPublicKey) Equals(k ic.Key) bool {
    42  	return ic.KeyEqual(pk, k)
    43  }
    44  
    45  func (pk TestBogusPublicKey) Hash() ([]byte, error) {
    46  	return ic.KeyHash(pk)
    47  }
    48  
    49  func (sk TestBogusPrivateKey) GenSecret() []byte {
    50  	return []byte(sk)
    51  }
    52  
    53  func (sk TestBogusPrivateKey) Sign(message []byte) ([]byte, error) {
    54  	log.Errorf("TestBogusPrivateKey.Sign -- this better be a test!")
    55  	return reverse(message), nil
    56  }
    57  
    58  func (sk TestBogusPrivateKey) GetPublic() ic.PubKey {
    59  	return TestBogusPublicKey(sk)
    60  }
    61  
    62  func (sk TestBogusPrivateKey) Decrypt(b []byte) ([]byte, error) {
    63  	log.Errorf("TestBogusPrivateKey.Decrypt -- this better be a test!")
    64  	return reverse(b), nil
    65  }
    66  
    67  func (sk TestBogusPrivateKey) Bytes() ([]byte, error) {
    68  	return []byte(sk), nil
    69  }
    70  
    71  // Equals checks whether this key is equal to another
    72  func (sk TestBogusPrivateKey) Equals(k ic.Key) bool {
    73  	return ic.KeyEqual(sk, k)
    74  }
    75  
    76  func (sk TestBogusPrivateKey) Hash() ([]byte, error) {
    77  	return ic.KeyHash(sk)
    78  }
    79  
    80  func RandTestBogusPrivateKey() (TestBogusPrivateKey, error) {
    81  	r := u.NewTimeSeededRand()
    82  	k := make([]byte, 5)
    83  	if _, err := io.ReadFull(r, k); err != nil {
    84  		return nil, err
    85  	}
    86  	return TestBogusPrivateKey(k), nil
    87  }
    88  
    89  func RandTestBogusPublicKey() (TestBogusPublicKey, error) {
    90  	k, err := RandTestBogusPrivateKey()
    91  	return TestBogusPublicKey(k), err
    92  }
    93  
    94  func RandTestBogusPrivateKeyOrFatal(t *testing.T) TestBogusPrivateKey {
    95  	k, err := RandTestBogusPrivateKey()
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  	return k
   100  }
   101  
   102  func RandTestBogusPublicKeyOrFatal(t *testing.T) TestBogusPublicKey {
   103  	k, err := RandTestBogusPublicKey()
   104  	if err != nil {
   105  		t.Fatal(err)
   106  	}
   107  	return k
   108  }
   109  
   110  func RandTestBogusIdentity() (testutil.Identity, error) {
   111  	k, err := RandTestBogusPrivateKey()
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  
   116  	id, err := peer.IDFromPrivateKey(k)
   117  	if err != nil {
   118  		return nil, err
   119  	}
   120  
   121  	return &identity{
   122  		k:  k,
   123  		id: id,
   124  		a:  testutil.RandLocalTCPAddress(),
   125  	}, nil
   126  }
   127  
   128  func RandTestBogusIdentityOrFatal(t *testing.T) testutil.Identity {
   129  	k, err := RandTestBogusIdentity()
   130  	if err != nil {
   131  		t.Fatal(err)
   132  	}
   133  	return k
   134  }
   135  
   136  // identity is a temporary shim to delay binding of PeerNetParams.
   137  type identity struct {
   138  	k  TestBogusPrivateKey
   139  	id peer.ID
   140  	a  ma.Multiaddr
   141  }
   142  
   143  func (p *identity) ID() peer.ID {
   144  	return p.id
   145  }
   146  
   147  func (p *identity) Address() ma.Multiaddr {
   148  	return p.a
   149  }
   150  
   151  func (p *identity) PrivateKey() ic.PrivKey {
   152  	return p.k
   153  }
   154  
   155  func (p *identity) PublicKey() ic.PubKey {
   156  	return p.k.GetPublic()
   157  }
   158  
   159  func reverse(a []byte) []byte {
   160  	b := make([]byte, len(a))
   161  	for i := 0; i < len(a); i++ {
   162  		b[i] = a[len(a)-1-i]
   163  	}
   164  	return b
   165  }