type Switch interface {
AddReactor(name string, reactor p2p.Reactor) p2p.Reactor
AddBannedPeer(string) error
- ID() [32]byte
}
// Chain is the interface for Bytom core.
"time"
log "github.com/sirupsen/logrus"
+ "github.com/tendermint/go-wire"
+ cmn "github.com/tendermint/tmlibs/common"
"golang.org/x/crypto/nacl/box"
"golang.org/x/crypto/nacl/secretbox"
"golang.org/x/crypto/ripemd160"
- "github.com/tendermint/go-crypto"
- wire "github.com/tendermint/go-wire"
- cmn "github.com/tendermint/tmlibs/common"
+ "github.com/vapor/p2p/signlib"
)
const (
dataMaxSize = 1024
totalFrameSize = dataMaxSize + dataLenSize
sealedFrameSize = totalFrameSize + secretbox.Overhead
- authSigMsgSize = (32 + 1) + (64 + 1) // fixed size (length prefixed) byte arrays
)
type authSigMessage struct {
- Key crypto.PubKey
- Sig crypto.Signature
+ Key []byte
+ Sig []byte
}
// SecretConnection implements net.Conn
recvBuffer []byte
recvNonce *[24]byte
sendNonce *[24]byte
- remPubKey crypto.PubKeyEd25519
+ remPubKey signlib.PubKey
shrSecret *[32]byte // shared secret
}
// MakeSecretConnection performs handshake and returns a new authenticated SecretConnection.
-func MakeSecretConnection(conn io.ReadWriteCloser, locPrivKey crypto.PrivKeyEd25519) (*SecretConnection, error) {
- locPubKey := locPrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
-
+func MakeSecretConnection(conn io.ReadWriteCloser, locPrivKey signlib.PrivKey) (*SecretConnection, error) {
// Generate ephemeral keys for perfect forward secrecy.
locEphPub, locEphPriv := genEphKeys()
// Sign the challenge bytes for authentication.
locSignature := signChallenge(challenge, locPrivKey)
-
// Share (in secret) each other's pubkey & challenge signature
- authSigMsg, err := shareAuthSignature(sc, locPubKey, locSignature)
+ authSigMsg, err := shareAuthSignature(sc, locPrivKey.XPub().Bytes(), locSignature)
+ if err != nil {
+ return nil, err
+ }
+ pubKey, remSignature := authSigMsg.Key, authSigMsg.Sig
+ remPubKey, err := signlib.NewPubKey(pubKey)
if err != nil {
return nil, err
}
- remPubKey, remSignature := authSigMsg.Key, authSigMsg.Sig
- if !remPubKey.VerifyBytes(challenge[:], remSignature) {
+
+ if !remPubKey.Verify(challenge[:], remSignature[:]) {
return nil, errors.New("Challenge verification failed")
}
- sc.remPubKey = remPubKey.Unwrap().(crypto.PubKeyEd25519)
+ sc.remPubKey = remPubKey
return sc, nil
}
}
// RemotePubKey returns authenticated remote pubkey
-func (sc *SecretConnection) RemotePubKey() crypto.PubKeyEd25519 {
+func (sc *SecretConnection) RemotePubKey() signlib.PubKey {
return sc.remPubKey
}
return nonce2, nonce1
}
-func signChallenge(challenge *[32]byte, locPrivKey crypto.PrivKeyEd25519) (signature crypto.SignatureEd25519) {
- signature = locPrivKey.Sign(challenge[:]).Unwrap().(crypto.SignatureEd25519)
- return
+func signChallenge(challenge *[32]byte, locPrivKey signlib.PrivKey) []byte {
+ return locPrivKey.Sign(challenge[:])
}
-func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKeyEd25519, signature crypto.SignatureEd25519) (*authSigMessage, error) {
+func shareAuthSignature(sc *SecretConnection, pubKey []byte, signature []byte) (*authSigMessage, error) {
var recvMsg authSigMessage
var err1, err2 error
cmn.Parallel(
func() {
- msgBytes := wire.BinaryBytes(authSigMessage{pubKey.Wrap(), signature.Wrap()})
+ msgBytes := wire.BinaryBytes(authSigMessage{pubKey, signature})
_, err1 = sc.Write(msgBytes)
},
func() {
- readBuffer := make([]byte, authSigMsgSize)
+ readBuffer := make([]byte, signlib.AuthSigMsgSize)
_, err2 = io.ReadFull(sc, readBuffer)
if err2 != nil {
return
}
n := int(0) // not used.
- recvMsg = wire.ReadBinary(authSigMessage{}, bytes.NewBuffer(readBuffer), authSigMsgSize, &n, &err2).(authSigMessage)
+ recvMsg = wire.ReadBinary(authSigMessage{}, bytes.NewBuffer(readBuffer), signlib.AuthSigMsgSize, &n, &err2).(authSigMessage)
},
)
-
if err1 != nil {
return nil, err1
}
"io"
"testing"
- "github.com/tendermint/go-crypto"
cmn "github.com/tendermint/tmlibs/common"
+
+ "github.com/vapor/crypto/ed25519/chainkd"
)
type dummyConn struct {
func makeSecretConnPair(tb testing.TB) (fooSecConn, barSecConn *SecretConnection) {
fooConn, barConn := makeDummyConnPair()
- fooPrvKey := crypto.GenPrivKeyEd25519()
- fooPubKey := fooPrvKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
- barPrvKey := crypto.GenPrivKeyEd25519()
- barPubKey := barPrvKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
+ fooPrvKey, _ := chainkd.NewXPrv(nil)
+ fooPubKey := fooPrvKey.XPub()
+ barPrvKey, _ := chainkd.NewXPrv(nil)
+ barPubKey := barPrvKey.XPub()
cmn.Parallel(
func() {
return
}
remotePubBytes := fooSecConn.RemotePubKey()
- if !bytes.Equal(remotePubBytes[:], barPubKey[:]) {
+ if !bytes.Equal(remotePubBytes.Bytes()[:], barPubKey[:]) {
tb.Errorf("Unexpected fooSecConn.RemotePubKey. Expected %v, got %v",
barPubKey, fooSecConn.RemotePubKey())
}
return
}
remotePubBytes := barSecConn.RemotePubKey()
- if !bytes.Equal(remotePubBytes[:], fooPubKey[:]) {
+ if !bytes.Equal(remotePubBytes.Bytes()[:], fooPubKey[:]) {
tb.Errorf("Unexpected barSecConn.RemotePubKey. Expected %v, got %v",
fooPubKey, barSecConn.RemotePubKey())
}
genNodeRunner := func(nodeConn dummyConn, nodeWrites []string, nodeReads *[]string) func() {
return func() {
// Node handskae
- nodePrvKey := crypto.GenPrivKeyEd25519()
+ nodePrvKey, _ := chainkd.NewXPrv(nil)
nodeSecretConn, err := MakeSecretConnection(nodeConn, nodePrvKey)
if err != nil {
t.Errorf("Failed to establish SecretConnection for node: %v", err)
"golang.org/x/crypto/sha3"
"github.com/vapor/common"
- "github.com/vapor/crypto/ed25519"
"github.com/vapor/crypto/sha3pool"
"github.com/vapor/p2p/netutil"
+ "github.com/vapor/p2p/signlib"
)
var (
return common.BytesToHash(h[:])
}
-func newNetwork(conn transport, ourPubkey ed25519.PublicKey, dbPath string, netrestrict *netutil.Netlist) (*Network, error) {
+func newNetwork(conn transport, ourPubkey signlib.PubKey, dbPath string, netrestrict *netutil.Netlist) (*Network, error) {
var ourID NodeID
- copy(ourID[:], ourPubkey[:nodeIDBits])
+ copy(ourID[:], ourPubkey.Bytes()[:nodeIDBits])
var db *nodeDB
if dbPath != "<no database>" {
"time"
"github.com/vapor/common"
- "github.com/vapor/crypto/ed25519"
+ "github.com/vapor/p2p/signlib"
)
func TestNetwork_Lookup(t *testing.T) {
}
defer os.RemoveAll(tmpDir)
- pubKey, _, err := ed25519.GenerateKey(nil)
- network, err := newNetwork(lookupTestnet, pubKey, tmpDir, nil)
+ privKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ network, err := newNetwork(lookupTestnet, privKey.XPub(), tmpDir, nil)
if err != nil {
t.Fatal(err)
}
var dists [hashBits + 1][]NodeID
found := 0
for found < bucketSize*10 {
- pubKey, _, _ := ed25519.GenerateKey(nil)
+ privKey, _ := signlib.NewPrivKey()
+ pubKey := privKey.XPub()
sha := hash(pubKey[:])
ld := logdist(targetSha, sha)
if len(dists[ld]) < bucketSize {
"github.com/vapor/common"
cfg "github.com/vapor/config"
"github.com/vapor/crypto"
- "github.com/vapor/crypto/ed25519"
"github.com/vapor/p2p/netutil"
+ "github.com/vapor/p2p/signlib"
"github.com/vapor/version"
)
// udp implements the RPC protocol.
type udp struct {
conn conn
- priv ed25519.PrivateKey
+ priv signlib.PrivKey
//netID used to isolate subnets
netID uint64
ourEndpoint rpcEndpoint
}
//NewDiscover create new dht discover
-func NewDiscover(config *cfg.Config, priv ed25519.PrivateKey, port uint16, netID uint64) (*Network, error) {
+func NewDiscover(config *cfg.Config, privKey signlib.PrivKey, port uint16, netID uint64) (*Network, error) {
addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort("0.0.0.0", strconv.FormatUint(uint64(port), 10)))
if err != nil {
return nil, err
}
realaddr := conn.LocalAddr().(*net.UDPAddr)
- ntab, err := ListenUDP(priv, conn, realaddr, path.Join(config.DBDir(), "discover"), nil, netID)
+ ntab, err := ListenUDP(privKey, conn, realaddr, path.Join(config.DBDir(), "discover"), nil, netID)
if err != nil {
return nil, err
}
}
// ListenUDP returns a new table that listens for UDP packets on laddr.
-func ListenUDP(priv ed25519.PrivateKey, conn conn, realaddr *net.UDPAddr, nodeDBPath string, netrestrict *netutil.Netlist, netID uint64) (*Network, error) {
- transport, err := listenUDP(priv, conn, realaddr, netID)
+func ListenUDP(privKey signlib.PrivKey, conn conn, realaddr *net.UDPAddr, nodeDBPath string, netrestrict *netutil.Netlist, netID uint64) (*Network, error) {
+ transport, err := listenUDP(privKey, conn, realaddr, netID)
if err != nil {
return nil, err
}
- net, err := newNetwork(transport, priv.Public(), nodeDBPath, netrestrict)
+ net, err := newNetwork(transport, privKey.XPub(), nodeDBPath, netrestrict)
if err != nil {
return nil, err
}
return net, nil
}
-func listenUDP(priv ed25519.PrivateKey, conn conn, realaddr *net.UDPAddr, netID uint64) (*udp, error) {
+func listenUDP(priv signlib.PrivKey, conn conn, realaddr *net.UDPAddr, netID uint64) (*udp, error) {
return &udp{conn: conn, priv: priv, netID: netID, ourEndpoint: makeEndpoint(realaddr, uint16(realaddr.Port))}, nil
}
// zeroed padding space for encodePacket.
var headSpace = make([]byte, headSize)
-func encodePacket(priv ed25519.PrivateKey, ptype byte, req interface{}, netID uint64) (p, hash []byte, err error) {
+func encodePacket(privKey signlib.PrivKey, ptype byte, req interface{}, netID uint64) (p, hash []byte, err error) {
b := new(bytes.Buffer)
b.Write(headSpace)
b.WriteByte(ptype)
return nil, nil, err
}
packet := b.Bytes()
- nodeID := priv.Public()
- sig := ed25519.Sign(priv, common.BytesToHash(packet[headSize:]).Bytes())
+ nodeID := privKey.XPub()
+ sig := privKey.Sign(common.BytesToHash(packet[headSize:]).Bytes())
id := []byte(strconv.FormatUint(netID, 16))
copy(packet[:], id[:])
- copy(packet[netIDSize:], nodeID[:])
+ copy(packet[netIDSize:], nodeID[:nodeIDSize])
copy(packet[netIDSize+nodeIDSize:], sig)
hash = common.BytesToHash(packet[:]).Bytes()
"github.com/davecgh/go-spew/spew"
"github.com/vapor/common"
- "github.com/vapor/crypto/ed25519"
"github.com/vapor/errors"
+ "github.com/vapor/p2p/signlib"
)
func TestPacketCodec(t *testing.T) {
},
}
- _, privateKey, _ := ed25519.GenerateKey(nil)
+ privateKey, _ := signlib.NewPrivKey()
netID := uint64(0x12345)
for i, test := range testPackets {
packet, h, err := encodePacket(privateKey, test.ptype, test.wantPacket, netID)
inConn := &testConn{conn: c1}
realaddr := &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 40000}
toAddr := &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 40000}
- _, inPrivKey, _ := ed25519.GenerateKey(nil)
- _, outPrivKey, _ := ed25519.GenerateKey(nil)
+ inPrivKey, _ := signlib.NewPrivKey()
+ outPrivKey, _ := signlib.NewPrivKey()
netID := uint64(0x12345)
udpInput, err := listenUDP(inPrivKey, inConn, realaddr, netID)
c1, c2 := net.Pipe()
inConn := &testConn{conn: c1}
realaddr := &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 40000}
- _, inPrivKey, _ := ed25519.GenerateKey(nil)
- _, outPrivKey, _ := ed25519.GenerateKey(nil)
+ inPrivKey, _ := signlib.NewPrivKey()
+ outPrivKey, _ := signlib.NewPrivKey()
netID := uint64(0x12345)
udpInput, err := listenUDP(inPrivKey, inConn, realaddr, netID)
"fmt"
"net"
- "github.com/tendermint/go-crypto"
-
cfg "github.com/vapor/config"
"github.com/vapor/consensus"
"github.com/vapor/errors"
+ "github.com/vapor/p2p/signlib"
"github.com/vapor/version"
)
//NodeInfo peer node info
type NodeInfo struct {
- PubKey crypto.PubKeyEd25519 `json:"pub_key"`
- Moniker string `json:"moniker"`
- Network string `json:"network"`
+ PubKey string `json:"pub_key"`
+ Moniker string `json:"moniker"`
+ Network string `json:"network"`
//NetworkID used to isolate subnets with same network name
NetworkID uint64 `json:"network_id"`
RemoteAddr string `json:"remote_addr"`
Other []string `json:"other"`
}
-func NewNodeInfo(config *cfg.Config, pubkey crypto.PubKeyEd25519, listenAddr string, netID uint64) *NodeInfo {
+func NewNodeInfo(config *cfg.Config, pubkey signlib.PubKey, listenAddr string, netID uint64) *NodeInfo {
return &NodeInfo{
- PubKey: pubkey,
+ PubKey: pubkey.String(),
Moniker: config.Moniker,
Network: config.ChainID,
NetworkID: netID,
"testing"
"github.com/davecgh/go-spew/spew"
- "github.com/tendermint/go-crypto"
"github.com/tendermint/go-wire"
"github.com/vapor/errors"
+ "github.com/vapor/p2p/signlib"
)
func mockCompatibleWithFalse(remoteVerStr string) (bool, error) {
}
func TestNodeInfoWriteRead(t *testing.T) {
- nodeInfo := &NodeInfo{PubKey: crypto.GenPrivKeyEd25519().PubKey().Unwrap().(crypto.PubKeyEd25519), Moniker: "bytomd", Network: "mainnet", NetworkID: 0x888, RemoteAddr: "127.0.0.2:0", ListenAddr: "127.0.0.1:0", Version: "1.1.0-test", ServiceFlag: 10, Other: []string{"abc", "bcd"}}
- n, err, err1 := new(int), new(error), new(error)
+ key := [64]byte{0x01, 0x02}
+ pubKey, err := signlib.NewPubKey(key[:])
+ if err != nil {
+ t.Fatal("create pubkey err.", err)
+ }
+ nodeInfo := &NodeInfo{PubKey: pubKey.String(), Moniker: "bytomd", Network: "mainnet", NetworkID: 0x888, RemoteAddr: "127.0.0.2:0", ListenAddr: "127.0.0.1:0", Version: "1.1.0-test", ServiceFlag: 10, Other: []string{"abc", "bcd"}}
+ n, err1, err2 := new(int), new(error), new(error)
buf := new(bytes.Buffer)
- wire.WriteBinary(nodeInfo, buf, n, err)
- if *err != nil {
- t.Fatal(*err)
+ wire.WriteBinary(nodeInfo, buf, n, err1)
+ if *err1 != nil {
+ t.Fatal(*err1)
}
peerNodeInfo := new(NodeInfo)
- wire.ReadBinary(peerNodeInfo, buf, maxNodeInfoSize, new(int), err1)
- if *err1 != nil {
+ wire.ReadBinary(peerNodeInfo, buf, maxNodeInfoSize, new(int), err2)
+ if *err2 != nil {
t.Fatal(*err1)
}
"github.com/btcsuite/go-socks/socks"
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/go-crypto"
"github.com/tendermint/go-wire"
cmn "github.com/tendermint/tmlibs/common"
"github.com/tendermint/tmlibs/flowrate"
cfg "github.com/vapor/config"
"github.com/vapor/consensus"
"github.com/vapor/p2p/connection"
+ "github.com/vapor/p2p/signlib"
)
// peerConn contains the raw connection and its config.
p := &Peer{
peerConn: pc,
NodeInfo: nodeInfo,
- Key: nodeInfo.PubKey.KeyString(),
+ Key: nodeInfo.PubKey,
isLAN: isLAN,
}
p.mconn = createMConnection(pc.conn, p, reactorsByCh, chDescs, onPeerError, pc.config.MConfig)
return p
}
-func newOutboundPeerConn(addr *NetAddress, ourNodePrivKey crypto.PrivKeyEd25519, config *PeerConfig) (*peerConn, error) {
+func newOutboundPeerConn(addr *NetAddress, ourNodePrivKey signlib.PrivKey, config *PeerConfig) (*peerConn, error) {
conn, err := dial(addr, config)
if err != nil {
return nil, errors.Wrap(err, "Error dial peer")
return pc, nil
}
-func newInboundPeerConn(conn net.Conn, ourNodePrivKey crypto.PrivKeyEd25519, config *cfg.P2PConfig) (*peerConn, error) {
+func newInboundPeerConn(conn net.Conn, ourNodePrivKey signlib.PrivKey, config *cfg.P2PConfig) (*peerConn, error) {
return newPeerConn(conn, false, ourNodePrivKey, DefaultPeerConfig(config))
}
-func newPeerConn(rawConn net.Conn, outbound bool, ourNodePrivKey crypto.PrivKeyEd25519, config *PeerConfig) (*peerConn, error) {
+func newPeerConn(rawConn net.Conn, outbound bool, ourNodePrivKey signlib.PrivKey, config *PeerConfig) (*peerConn, error) {
rawConn.SetDeadline(time.Now().Add(config.HandshakeTimeout))
conn, err := connection.MakeSecretConnection(rawConn, ourNodePrivKey)
if err != nil {
}
// PubKey returns peer's public key.
-func (p *Peer) PubKey() crypto.PubKeyEd25519 {
- return p.conn.(*connection.SecretConnection).RemotePubKey()
+func (p *Peer) PubKey() string {
+ return p.conn.(*connection.SecretConnection).RemotePubKey().String()
}
// Send msg to the channel identified by chID byte. Returns false if the send
"testing"
"time"
- "github.com/tendermint/go-crypto"
-
cfg "github.com/vapor/config"
conn "github.com/vapor/p2p/connection"
+ "github.com/vapor/p2p/signlib"
"github.com/vapor/version"
)
const testCh = 0x01
func TestPeerBasic(t *testing.T) {
+ privKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
// simulate remote peer
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: testCfg}
+ rp := &remotePeer{PrivKey: privKey, Config: testCfg}
rp.Start()
defer rp.Stop()
func TestPeerSend(t *testing.T) {
config := testCfg
-
+ privKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
// simulate remote peer
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
+ rp := &remotePeer{PrivKey: privKey, Config: config}
rp.Start()
defer rp.Stop()
{ID: testCh, Priority: 1},
}
reactorsByCh := map[byte]Reactor{testCh: NewTestReactor(chDescs, true)}
- privkey := crypto.GenPrivKeyEd25519()
+ privKey, err := signlib.NewPrivKey()
+ if err != nil {
+ return nil, err
+ }
peerConfig := DefaultPeerConfig(config)
- pc, err := newOutboundPeerConn(addr, privkey, peerConfig)
+ pc, err := newOutboundPeerConn(addr, privKey, peerConfig)
if err != nil {
return nil, err
}
}
type remotePeer struct {
- PrivKey crypto.PrivKeyEd25519
+ PrivKey signlib.PrivKey
Config *cfg.Config
addr *NetAddress
quit chan struct{}
}
_, err = pc.HandshakeTimeout(&NodeInfo{
- PubKey: rp.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
+ PubKey: rp.PrivKey.XPub().String(),
Moniker: "remote_peer",
Network: rp.Config.ChainID,
Version: version.Version,
}
type inboundPeer struct {
- PrivKey crypto.PrivKeyEd25519
+ PrivKey signlib.PrivKey
config *cfg.Config
}
}
_, err = pc.HandshakeTimeout(&NodeInfo{
- PubKey: ip.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
+ PubKey: ip.PrivKey.XPub().String(),
Moniker: "remote_peer",
Network: ip.config.ChainID,
Version: version.Version,
--- /dev/null
+package signlib
+
+import (
+ "errors"
+
+ "github.com/vapor/crypto/ed25519/chainkd"
+)
+
+const (
+ PubkeySize = 64
+ AuthSigMsgSize = 132
+)
+
+var (
+ ErrPubkeyLength = errors.New("pubkey length error")
+)
+
+type PubKey interface {
+ String() string
+ Bytes() []byte
+ Verify(msg []byte, sig []byte) bool
+ MarshalText() ([]byte, error)
+}
+
+type PrivKey interface {
+ Bytes() []byte
+ Sign(msg []byte) []byte
+ XPub() chainkd.XPub
+}
+
+func NewPrivKey() (PrivKey, error) {
+ return chainkd.NewXPrv(nil)
+}
+
+func NewPubKey(pubkey []byte) (PubKey, error) {
+ if len(pubkey) != PubkeySize {
+ return nil, ErrPubkeyLength
+ }
+
+ var pubKey chainkd.XPub
+ copy(pubKey[:], pubkey[:])
+ return pubKey, nil
+}
import (
"encoding/binary"
- "encoding/hex"
"encoding/json"
"fmt"
"net"
"time"
log "github.com/sirupsen/logrus"
- crypto "github.com/tendermint/go-crypto"
cmn "github.com/tendermint/tmlibs/common"
cfg "github.com/vapor/config"
"github.com/vapor/consensus"
- "github.com/vapor/crypto/ed25519"
"github.com/vapor/crypto/sha3pool"
dbm "github.com/vapor/database/leveldb"
"github.com/vapor/errors"
"github.com/vapor/p2p/discover/dht"
"github.com/vapor/p2p/discover/mdns"
"github.com/vapor/p2p/netutil"
+ "github.com/vapor/p2p/signlib"
"github.com/vapor/p2p/trust"
"github.com/vapor/version"
)
reactorsByCh map[byte]Reactor
peers *PeerSet
dialing *cmn.CMap
- nodeInfo *NodeInfo // our node info
- nodePrivKey crypto.PrivKeyEd25519 // our node privkey
+ nodeInfo *NodeInfo // our node info
+ nodePrivKey signlib.PrivKey // our node privkey
discv discv
lanDiscv lanDiscv
bannedPeer map[string]time.Time
netID := binary.BigEndian.Uint64(h[:8])
blacklistDB := dbm.NewDB("trusthistory", config.DBBackend, config.DBDir())
-
- _, yyy, _ := ed25519.GenerateKey(nil)
- zzz := yyy.String()
-
- bytes, err := hex.DecodeString(zzz)
- if err != nil {
- return nil, err
- }
- var newKey [64]byte
- copy(newKey[:], bytes)
- privKey := crypto.PrivKeyEd25519(newKey)
+ privateKey := config.PrivateKey()
if !config.VaultMode {
// Create listener
l, listenAddr = GetListener(config.P2P)
- discv, err = dht.NewDiscover(config, ed25519.PrivateKey(bytes), l.ExternalAddress().Port, netID)
+ discv, err = dht.NewDiscover(config, *privateKey, l.ExternalAddress().Port, netID)
if err != nil {
return nil, err
}
}
}
- return newSwitch(config, discv, lanDiscv, blacklistDB, l, privKey, listenAddr, netID)
+ return newSwitch(config, discv, lanDiscv, blacklistDB, l, *privateKey, listenAddr, netID)
}
// newSwitch creates a new Switch with the given config.
-func newSwitch(config *cfg.Config, discv discv, lanDiscv lanDiscv, blacklistDB dbm.DB, l Listener, priv crypto.PrivKeyEd25519, listenAddr string, netID uint64) (*Switch, error) {
+func newSwitch(config *cfg.Config, discv discv, lanDiscv lanDiscv, blacklistDB dbm.DB, l Listener, privKey signlib.PrivKey, listenAddr string, netID uint64) (*Switch, error) {
sw := &Switch{
Config: config,
peerConfig: DefaultPeerConfig(config.P2P),
reactorsByCh: make(map[byte]Reactor),
peers: NewPeerSet(),
dialing: cmn.NewCMap(),
- nodePrivKey: priv,
+ nodePrivKey: privKey,
discv: discv,
lanDiscv: lanDiscv,
db: blacklistDB,
- nodeInfo: NewNodeInfo(config, priv.PubKey().Unwrap().(crypto.PubKeyEd25519), listenAddr, netID),
+ nodeInfo: NewNodeInfo(config, privKey.XPub(), listenAddr, netID),
bannedPeer: make(map[string]time.Time),
}
if err := sw.loadBannedPeers(); err != nil {
return nil
}
-func (sw *Switch) ID() [32]byte {
- return sw.nodeInfo.PubKey
-}
-
//IsDialing prevent duplicate dialing
func (sw *Switch) IsDialing(addr *NetAddress) bool {
return sw.dialing.Has(addr.IP.String())
return err
}
- if sw.nodeInfo.PubKey.Equals(peer.PubKey().Wrap()) {
+ if sw.nodeInfo.PubKey == peer.PubKey() {
return ErrConnectSelf
}
"time"
"github.com/davecgh/go-spew/spew"
- "github.com/tendermint/go-crypto"
-
cfg "github.com/vapor/config"
dbm "github.com/vapor/database/leveldb"
"github.com/vapor/errors"
conn "github.com/vapor/p2p/connection"
+ "github.com/vapor/p2p/signlib"
)
var (
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
cfg := *testCfg
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
cfg := *testCfg
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
rpCfg := *testCfg
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: &rpCfg}
+ remotePrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rp := &remotePeer{PrivKey: remotePrivKey, Config: &rpCfg}
rp.Start()
defer rp.Stop()
s1.AddBannedPeer(rp.addr.IP.String())
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
cfg := *testCfg
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
rpCfg := *testCfg
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: &rpCfg}
+ remotePrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ rp := &remotePeer{PrivKey: remotePrivKey, Config: &rpCfg}
rp.Start()
defer rp.Stop()
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
cfg := *testCfg
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
inpCfg := *testCfg
- inp := &inboundPeer{PrivKey: crypto.GenPrivKeyEd25519(), config: &inpCfg}
+ inpPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
if err != nil {
t.Fatal(err)
cfg := *testCfg
cfg.P2P.MaxNumPeers = 2
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
inpCfg := *testCfg
- inpPrivKey := crypto.GenPrivKeyEd25519()
- //inpCfg.P2P.PrivateKey = inpPrivKey.String()
+ inpPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
if err != nil {
go inp.dial(addr)
rpCfg := *testCfg
- rpPrivKey := crypto.GenPrivKeyEd25519()
- //rpCfg.P2P.PrivateKey = rpPrivKey.String()
+ rpPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
rp := &remotePeer{PrivKey: rpPrivKey, Config: &rpCfg}
rp.Start()
defer rp.Stop()
}
inp2Cfg := *testCfg
- inp2PrivKey := crypto.GenPrivKeyEd25519()
- //inp2Cfg.P2P.PrivateKey = inp2PrivKey.String()
+
+ inp2PrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
inp2 := &inboundPeer{PrivKey: inp2PrivKey, config: &inp2Cfg}
go inp2.dial(addr)
cfg := *testCfg
cfg.P2P.MaxNumPeers = 2
cfg.P2P.ListenAddress = "127.0.1.1:0"
- swPrivKey := crypto.GenPrivKeyEd25519()
- //cfg.P2P.PrivateKey = swPrivKey.String()
+ swPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
s1 := MakeSwitch(&cfg, testDB, swPrivKey, initSwitchFunc)
s1.Start()
defer s1.Stop()
inpCfg := *testCfg
- inpPrivKey := crypto.GenPrivKeyEd25519()
- //inpCfg.P2P.PrivateKey = inpPrivKey.String()
- inp := &inboundPeer{PrivKey: inpPrivKey, config: &inpCfg}
+ inp2PrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+ inp := &inboundPeer{PrivKey: inp2PrivKey, config: &inpCfg}
addr := NewNetAddress(s1.listeners[0].(*DefaultListener).NetListener().Addr())
if err != nil {
t.Fatal(err)
go inp.dial(addr)
rpCfg := *testCfg
- rpPrivKey := crypto.GenPrivKeyEd25519()
- //rpCfg.P2P.PrivateKey = rpPrivKey.String()
+ rpPrivKey, err := signlib.NewPrivKey()
+ if err != nil {
+ t.Fatal(err)
+ }
+
rp := &remotePeer{PrivKey: rpPrivKey, Config: &rpCfg}
rp.Start()
defer rp.Stop()
"net"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/go-crypto"
cmn "github.com/tendermint/tmlibs/common"
cfg "github.com/vapor/config"
dbm "github.com/vapor/database/leveldb"
"github.com/vapor/p2p/connection"
"github.com/vapor/p2p/discover/dht"
+ "github.com/vapor/p2p/signlib"
)
//PanicOnAddPeerErr add peer error
return 0
}
-func MakeSwitch(cfg *cfg.Config, testdb dbm.DB, privKey crypto.PrivKeyEd25519, initSwitch func(*Switch) *Switch) *Switch {
+func MakeSwitch(cfg *cfg.Config, testdb dbm.DB, privKey signlib.PrivKey, initSwitch func(*Switch) *Switch) *Switch {
// new switch, add reactors
l, listenAddr := GetListener(cfg.P2P)
cfg.P2P.LANDiscover = false