mirror of
https://github.com/ipfs/kubo.git
synced 2026-02-25 12:27:43 +08:00
07b064010e
refactor test peer creation to be deterministic and reliable a bit of cleanup trying to figure out TestGetFailure add test to verify deterministic peer creation switch put RPC over to use getClosestPeers rm 0xDEADC0DE fix queries not searching peer if its not actually closer
121 lines
2.0 KiB
Go
121 lines
2.0 KiB
Go
package crypto
|
|
|
|
import (
|
|
"bytes"
|
|
u "github.com/jbenet/go-ipfs/util"
|
|
"testing"
|
|
)
|
|
|
|
func TestRsaKeys(t *testing.T) {
|
|
sk, pk, err := GenerateKeyPair(RSA, 512, u.NewTimeSeededRand())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testKeySignature(t, sk)
|
|
testKeyEncoding(t, sk)
|
|
testKeyEquals(t, sk)
|
|
testKeyEquals(t, pk)
|
|
}
|
|
|
|
func testKeySignature(t *testing.T, sk PrivKey) {
|
|
pk := sk.GetPublic()
|
|
|
|
text := sk.GenSecret()
|
|
sig, err := sk.Sign(text)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
valid, err := pk.Verify(text, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !valid {
|
|
t.Fatal("Invalid signature.")
|
|
}
|
|
}
|
|
|
|
func testKeyEncoding(t *testing.T, sk PrivKey) {
|
|
skbm, err := MarshalPrivateKey(sk)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sk2, err := UnmarshalPrivateKey(skbm)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
skbm2, err := MarshalPrivateKey(sk2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !bytes.Equal(skbm, skbm2) {
|
|
t.Error("skb -> marshal -> unmarshal -> skb failed.\n", skbm, "\n", skbm2)
|
|
}
|
|
|
|
pk := sk.GetPublic()
|
|
pkbm, err := MarshalPublicKey(pk)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err = UnmarshalPublicKey(pkbm)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
pkbm2, err := MarshalPublicKey(pk)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !bytes.Equal(pkbm, pkbm2) {
|
|
t.Error("skb -> marshal -> unmarshal -> skb failed.\n", pkbm, "\n", pkbm2)
|
|
}
|
|
}
|
|
|
|
func testKeyEquals(t *testing.T, k Key) {
|
|
kb, err := k.Bytes()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !KeyEqual(k, k) {
|
|
t.Fatal("Key not equal to itself.")
|
|
}
|
|
|
|
if !KeyEqual(k, testkey(kb)) {
|
|
t.Fatal("Key not equal to key with same bytes.")
|
|
}
|
|
|
|
sk, pk, err := GenerateKeyPair(RSA, 512, u.NewTimeSeededRand())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if KeyEqual(k, sk) {
|
|
t.Fatal("Keys should not equal.")
|
|
}
|
|
|
|
if KeyEqual(k, pk) {
|
|
t.Fatal("Keys should not equal.")
|
|
}
|
|
}
|
|
|
|
type testkey []byte
|
|
|
|
func (pk testkey) Bytes() ([]byte, error) {
|
|
return pk, nil
|
|
}
|
|
|
|
func (pk testkey) Equals(k Key) bool {
|
|
return KeyEqual(pk, k)
|
|
}
|
|
|
|
func (pk testkey) Hash() ([]byte, error) {
|
|
return KeyHash(pk)
|
|
}
|