mirror of
https://gitlab.com/pulsechaincom/go-pulse.git
synced 2024-12-25 04:47:17 +00:00
267 lines
7.5 KiB
Go
267 lines
7.5 KiB
Go
// Copyright 2018 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// +build foo
|
|
|
|
package pss
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/swarm/log"
|
|
)
|
|
|
|
// asymmetrical key exchange between two directly connected peers
|
|
// full address, partial address (8 bytes) and empty address
|
|
func TestHandshake(t *testing.T) {
|
|
t.Run("32", testHandshake)
|
|
t.Run("8", testHandshake)
|
|
t.Run("0", testHandshake)
|
|
}
|
|
|
|
func testHandshake(t *testing.T) {
|
|
|
|
// how much of the address we will use
|
|
useHandshake = true
|
|
var addrsize int64
|
|
var err error
|
|
addrsizestring := strings.Split(t.Name(), "/")
|
|
addrsize, _ = strconv.ParseInt(addrsizestring[1], 10, 0)
|
|
|
|
// set up two nodes directly connected
|
|
// (we are not testing pss routing here)
|
|
clients, err := setupNetwork(2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var topic string
|
|
err = clients[0].Call(&topic, "pss_stringToTopic", "foo:42")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var loaddr string
|
|
err = clients[0].Call(&loaddr, "pss_baseAddr")
|
|
if err != nil {
|
|
t.Fatalf("rpc get node 1 baseaddr fail: %v", err)
|
|
}
|
|
// "0x" = 2 bytes + addrsize address bytes which in hex is 2x length
|
|
loaddr = loaddr[:2+(addrsize*2)]
|
|
var roaddr string
|
|
err = clients[1].Call(&roaddr, "pss_baseAddr")
|
|
if err != nil {
|
|
t.Fatalf("rpc get node 2 baseaddr fail: %v", err)
|
|
}
|
|
roaddr = roaddr[:2+(addrsize*2)]
|
|
log.Debug("addresses", "left", loaddr, "right", roaddr)
|
|
|
|
// retrieve public key from pss instance
|
|
// set this public key reciprocally
|
|
var lpubkey string
|
|
err = clients[0].Call(&lpubkey, "pss_getPublicKey")
|
|
if err != nil {
|
|
t.Fatalf("rpc get node 1 pubkey fail: %v", err)
|
|
}
|
|
var rpubkey string
|
|
err = clients[1].Call(&rpubkey, "pss_getPublicKey")
|
|
if err != nil {
|
|
t.Fatalf("rpc get node 2 pubkey fail: %v", err)
|
|
}
|
|
|
|
time.Sleep(time.Millisecond * 1000) // replace with hive healthy code
|
|
|
|
// give each node its peer's public key
|
|
err = clients[0].Call(nil, "pss_setPeerPublicKey", rpubkey, topic, roaddr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = clients[1].Call(nil, "pss_setPeerPublicKey", lpubkey, topic, loaddr)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// perform the handshake
|
|
// after this each side will have defaultSymKeyBufferCapacity symkeys each for in- and outgoing messages:
|
|
// L -> request 4 keys -> R
|
|
// L <- send 4 keys, request 4 keys <- R
|
|
// L -> send 4 keys -> R
|
|
// the call will fill the array with symkeys L needs for sending to R
|
|
err = clients[0].Call(nil, "pss_addHandshake", topic)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = clients[1].Call(nil, "pss_addHandshake", topic)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var lhsendsymkeyids []string
|
|
err = clients[0].Call(&lhsendsymkeyids, "pss_handshake", rpubkey, topic, true, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// make sure the r-node gets its keys
|
|
time.Sleep(time.Second)
|
|
|
|
// check if we have 6 outgoing keys stored, and they match what was received from R
|
|
var lsendsymkeyids []string
|
|
err = clients[0].Call(&lsendsymkeyids, "pss_getHandshakeKeys", rpubkey, topic, false, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := 0
|
|
for _, hid := range lhsendsymkeyids {
|
|
for _, lid := range lsendsymkeyids {
|
|
if lid == hid {
|
|
m++
|
|
}
|
|
}
|
|
}
|
|
if m != defaultSymKeyCapacity {
|
|
t.Fatalf("buffer size mismatch, expected %d, have %d: %v", defaultSymKeyCapacity, m, lsendsymkeyids)
|
|
}
|
|
|
|
// check if in- and outgoing keys on l-node and r-node match up and are in opposite categories (l recv = r send, l send = r recv)
|
|
var rsendsymkeyids []string
|
|
err = clients[1].Call(&rsendsymkeyids, "pss_getHandshakeKeys", lpubkey, topic, false, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var lrecvsymkeyids []string
|
|
err = clients[0].Call(&lrecvsymkeyids, "pss_getHandshakeKeys", rpubkey, topic, true, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var rrecvsymkeyids []string
|
|
err = clients[1].Call(&rrecvsymkeyids, "pss_getHandshakeKeys", lpubkey, topic, true, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// get outgoing symkeys in byte form from both sides
|
|
var lsendsymkeys []string
|
|
for _, id := range lsendsymkeyids {
|
|
var key string
|
|
err = clients[0].Call(&key, "pss_getSymmetricKey", id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
lsendsymkeys = append(lsendsymkeys, key)
|
|
}
|
|
var rsendsymkeys []string
|
|
for _, id := range rsendsymkeyids {
|
|
var key string
|
|
err = clients[1].Call(&key, "pss_getSymmetricKey", id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
rsendsymkeys = append(rsendsymkeys, key)
|
|
}
|
|
|
|
// get incoming symkeys in byte form from both sides and compare
|
|
var lrecvsymkeys []string
|
|
for _, id := range lrecvsymkeyids {
|
|
var key string
|
|
err = clients[0].Call(&key, "pss_getSymmetricKey", id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
match := false
|
|
for _, otherkey := range rsendsymkeys {
|
|
if otherkey == key {
|
|
match = true
|
|
}
|
|
}
|
|
if !match {
|
|
t.Fatalf("no match right send for left recv key %s", id)
|
|
}
|
|
lrecvsymkeys = append(lrecvsymkeys, key)
|
|
}
|
|
var rrecvsymkeys []string
|
|
for _, id := range rrecvsymkeyids {
|
|
var key string
|
|
err = clients[1].Call(&key, "pss_getSymmetricKey", id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
match := false
|
|
for _, otherkey := range lsendsymkeys {
|
|
if otherkey == key {
|
|
match = true
|
|
}
|
|
}
|
|
if !match {
|
|
t.Fatalf("no match left send for right recv key %s", id)
|
|
}
|
|
rrecvsymkeys = append(rrecvsymkeys, key)
|
|
}
|
|
|
|
// send new handshake request, should send no keys
|
|
err = clients[0].Call(nil, "pss_handshake", rpubkey, topic, false)
|
|
if err == nil {
|
|
t.Fatal("expected full symkey buffer error")
|
|
}
|
|
|
|
// expire one key, send new handshake request
|
|
err = clients[0].Call(nil, "pss_releaseHandshakeKey", rpubkey, topic, lsendsymkeyids[0], true)
|
|
if err != nil {
|
|
t.Fatalf("release left send key %s fail: %v", lsendsymkeyids[0], err)
|
|
}
|
|
|
|
var newlhsendkeyids []string
|
|
|
|
// send new handshake request, should now receive one key
|
|
// check that it is not in previous right recv key array
|
|
err = clients[0].Call(&newlhsendkeyids, "pss_handshake", rpubkey, topic, true, false)
|
|
if err != nil {
|
|
t.Fatalf("handshake send fail: %v", err)
|
|
} else if len(newlhsendkeyids) != defaultSymKeyCapacity {
|
|
t.Fatalf("wrong receive count, expected 1, got %d", len(newlhsendkeyids))
|
|
}
|
|
|
|
var newlrecvsymkey string
|
|
err = clients[0].Call(&newlrecvsymkey, "pss_getSymmetricKey", newlhsendkeyids[0])
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var rmatchsymkeyid *string
|
|
for i, id := range rrecvsymkeyids {
|
|
var key string
|
|
err = clients[1].Call(&key, "pss_getSymmetricKey", id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if newlrecvsymkey == key {
|
|
rmatchsymkeyid = &rrecvsymkeyids[i]
|
|
}
|
|
}
|
|
if rmatchsymkeyid != nil {
|
|
t.Fatalf("right sent old key id %s in second handshake", *rmatchsymkeyid)
|
|
}
|
|
|
|
// clean the pss core keystore. Should clean the key released earlier
|
|
var cleancount int
|
|
clients[0].Call(&cleancount, "psstest_clean")
|
|
if cleancount > 1 {
|
|
t.Fatalf("pss clean count mismatch; expected 1, got %d", cleancount)
|
|
}
|
|
}
|