test/fuzz: move fuzz tests into this repo (#5918)

Co-authored-by: Emmanuel T Odeke <emmanuel@orijtech.com>

Closes #5907

- add init-corpus to blockchain reactor
- remove validator-set FromBytes test
now that we have proto, we don't need to test it! bye amino
- simplify mempool test
do we want to test remote ABCI app?
- do not recreate mux on every crash in jsonrpc test
- update p2p pex reactor test
- remove p2p/listener test
the API has changed + I did not understand what it's tested anyway
- update secretconnection test
- add readme and makefile
- list inputs in readme
- add nightly workflow
- remove blockchain fuzz test
EncodeMsg / DecodeMsg no longer exist

test/fuzz/p2p/pex/init-corpus/main.go

@@ -0,0 +1,82 @@
+// nolint: gosec
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"os"
+	"path/filepath"
+
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/p2p"
+	tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
+)
+
+func main() {
+	baseDir := flag.String("base", ".", `where the "corpus" directory will live`)
+	flag.Parse()
+
+	initCorpus(*baseDir)
+}
+
+func initCorpus(rootDir string) {
+	log.SetFlags(0)
+
+	corpusDir := filepath.Join(rootDir, "corpus")
+	if err := os.MkdirAll(corpusDir, 0755); err != nil {
+		log.Fatalf("Creating %q err: %v", corpusDir, err)
+	}
+	sizes := []int{0, 1, 2, 17, 5, 31}
+
+	// Make the PRNG predictable
+	rand.Seed(10)
+
+	for _, n := range sizes {
+		var addrs []*p2p.NetAddress
+
+		// IPv4 addresses
+		for i := 0; i < n; i++ {
+			privKey := ed25519.GenPrivKey()
+			addr := fmt.Sprintf(
+				"%s@%v.%v.%v.%v:26656",
+				p2p.NodeIDFromPubKey(privKey.PubKey()),
+				rand.Int()%256,
+				rand.Int()%256,
+				rand.Int()%256,
+				rand.Int()%256,
+			)
+			netAddr, _ := p2p.NewNetAddressString(addr)
+			addrs = append(addrs, netAddr)
+		}
+
+		// IPv6 addresses
+		privKey := ed25519.GenPrivKey()
+		ipv6a, err := p2p.NewNetAddressString(
+			fmt.Sprintf("%s@[ff02::1:114]:26656", p2p.NodeIDFromPubKey(privKey.PubKey())))
+		if err != nil {
+			log.Fatalf("can't create a new netaddress: %v", err)
+		}
+		addrs = append(addrs, ipv6a)
+
+		msg := tmp2p.Message{
+			Sum: &tmp2p.Message_PexAddrs{
+				PexAddrs: &tmp2p.PexAddrs{Addrs: p2p.NetAddressesToProto(addrs)},
+			},
+		}
+		bz, err := msg.Marshal()
+		if err != nil {
+			log.Fatalf("unable to marshal: %v", err)
+		}
+
+		filename := filepath.Join(rootDir, "corpus", fmt.Sprintf("%d", n))
+
+		if err := ioutil.WriteFile(filename, bz, 0644); err != nil {
+			log.Fatalf("can't write %X to %q: %v", bz, filename, err)
+		}
+
+		log.Printf("wrote %q", filename)
+	}
+}

test/fuzz/p2p/pex/reactor_receive.go

@@ -0,0 +1,86 @@
+package pex
+
+import (
+	"net"
+
+	"github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/libs/service"
+	"github.com/tendermint/tendermint/p2p"
+	"github.com/tendermint/tendermint/p2p/pex"
+	"github.com/tendermint/tendermint/version"
+)
+
+var (
+	pexR *pex.Reactor
+	peer p2p.Peer
+)
+
+func init() {
+	addrB := pex.NewAddrBook("./testdata/addrbook1", false)
+	pexR := pex.NewReactor(addrB, &pex.ReactorConfig{SeedMode: false})
+	if pexR == nil {
+		panic("NewReactor returned nil")
+	}
+	pexR.SetLogger(log.NewNopLogger())
+	peer := newFuzzPeer()
+	pexR.AddPeer(peer)
+
+}
+
+func Fuzz(data []byte) int {
+	// MakeSwitch uses log.TestingLogger which can't be executed in init()
+	cfg := config.DefaultP2PConfig()
+	cfg.PexReactor = true
+	sw := p2p.MakeSwitch(cfg, 0, "127.0.0.1", "123.123.123", func(i int, sw *p2p.Switch) *p2p.Switch {
+		return sw
+	})
+	pexR.SetSwitch(sw)
+
+	pexR.Receive(pex.PexChannel, peer, data)
+	return 1
+}
+
+type fuzzPeer struct {
+	*service.BaseService
+	m map[string]interface{}
+}
+
+var _ p2p.Peer = (*fuzzPeer)(nil)
+
+func newFuzzPeer() *fuzzPeer {
+	fp := &fuzzPeer{m: make(map[string]interface{})}
+	fp.BaseService = service.NewBaseService(nil, "fuzzPeer", fp)
+	return fp
+}
+
+var privKey = ed25519.GenPrivKey()
+var nodeID = p2p.NodeIDFromPubKey(privKey.PubKey())
+var defaultNodeInfo = p2p.NodeInfo{
+	ProtocolVersion: p2p.NewProtocolVersion(
+		version.P2PProtocol,
+		version.BlockProtocol,
+		0,
+	),
+	NodeID:     nodeID,
+	ListenAddr: "0.0.0.0:98992",
+	Moniker:    "foo1",
+}
+
+func (fp *fuzzPeer) FlushStop()       {}
+func (fp *fuzzPeer) ID() p2p.NodeID   { return nodeID }
+func (fp *fuzzPeer) RemoteIP() net.IP { return net.IPv4(0, 0, 0, 0) }
+func (fp *fuzzPeer) RemoteAddr() net.Addr {
+	return &net.TCPAddr{IP: fp.RemoteIP(), Port: 98991, Zone: ""}
+}
+func (fp *fuzzPeer) IsOutbound() bool                  { return false }
+func (fp *fuzzPeer) IsPersistent() bool                { return false }
+func (fp *fuzzPeer) CloseConn() error                  { return nil }
+func (fp *fuzzPeer) NodeInfo() p2p.NodeInfo            { return defaultNodeInfo }
+func (fp *fuzzPeer) Status() p2p.ConnectionStatus      { var cs p2p.ConnectionStatus; return cs }
+func (fp *fuzzPeer) SocketAddr() *p2p.NetAddress       { return p2p.NewNetAddress(fp.ID(), fp.RemoteAddr()) }
+func (fp *fuzzPeer) Send(byte, []byte) bool            { return true }
+func (fp *fuzzPeer) TrySend(byte, []byte) bool         { return true }
+func (fp *fuzzPeer) Set(key string, value interface{}) { fp.m[key] = value }
+func (fp *fuzzPeer) Get(key string) interface{}        { return fp.m[key] }