whisper: remove whisper (#21487)

* whisper: remove whisper

* Update cmd/geth/config.go

Co-authored-by: Marius van der Wijden <m.vanderwijden@live.de>

* cmd/geth: warn on enabling whisper + remove more whisper deps

* mobile: remove all whisper references

Co-authored-by: Marius van der Wijden <m.vanderwijden@live.de>
Co-authored-by: Martin Holst Swende <martin@swende.se>

cmd/geth/config.go

@@ -29,9 +29,9 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
+	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/params"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 	"github.com/naoina/toml"
 )
 
@@ -75,7 +75,6 @@ type ethstatsConfig struct {
 
 type gethConfig struct {
 	Eth      eth.Config
-	Shh      whisper.Config
 	Node     node.Config
 	Ethstats ethstatsConfig
 }
@@ -110,7 +109,6 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 	// Load defaults.
 	cfg := gethConfig{
 		Eth:  eth.DefaultConfig,
-		Shh:  whisper.DefaultConfig,
 		Node: defaultNodeConfig(),
 	}
 
@@ -131,19 +129,18 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 	if ctx.GlobalIsSet(utils.EthStatsURLFlag.Name) {
 		cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name)
 	}
-	utils.SetShhConfig(ctx, stack, &cfg.Shh)
+	utils.SetShhConfig(ctx, stack)
 
 	return stack, cfg
 }
 
 // enableWhisper returns true in case one of the whisper flags is set.
-func enableWhisper(ctx *cli.Context) bool {
+func checkWhisper(ctx *cli.Context) {
 	for _, flag := range whisperFlags {
 		if ctx.GlobalIsSet(flag.GetName()) {
-			return true
+			log.Warn("deprecated whisper flag detected. Whisper has been moved to github.com/ethereum/whisper")
 		}
 	}
-	return false
 }
 
 // makeFullNode loads geth configuration and creates the Ethereum backend.
@@ -152,21 +149,7 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 
 	backend := utils.RegisterEthService(stack, &cfg.Eth)
 
-	// Whisper must be explicitly enabled by specifying at least 1 whisper flag or in dev mode
+	checkWhisper(ctx)
-	shhEnabled := enableWhisper(ctx)
-	shhAutoEnabled := !ctx.GlobalIsSet(utils.WhisperEnabledFlag.Name) && ctx.GlobalIsSet(utils.DeveloperFlag.Name)
-	if shhEnabled || shhAutoEnabled {
-		if ctx.GlobalIsSet(utils.WhisperMaxMessageSizeFlag.Name) {
-			cfg.Shh.MaxMessageSize = uint32(ctx.Int(utils.WhisperMaxMessageSizeFlag.Name))
-		}
-		if ctx.GlobalIsSet(utils.WhisperMinPOWFlag.Name) {
-			cfg.Shh.MinimumAcceptedPOW = ctx.Float64(utils.WhisperMinPOWFlag.Name)
-		}
-		if ctx.GlobalIsSet(utils.WhisperRestrictConnectionBetweenLightClientsFlag.Name) {
-			cfg.Shh.RestrictConnectionBetweenLightClients = true
-		}
-		utils.RegisterShhService(stack, &cfg.Shh)
-	}
 	// Configure GraphQL if requested
 	if ctx.GlobalIsSet(utils.GraphQLEnabledFlag.Name) {
 		utils.RegisterGraphQLService(stack, backend, cfg.Node)

cmd/geth/consolecmd_test.go

@@ -31,7 +31,7 @@ import (
 )
 
 const (
-	ipcAPIs  = "admin:1.0 debug:1.0 eth:1.0 ethash:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 shh:1.0 txpool:1.0 web3:1.0"
+	ipcAPIs  = "admin:1.0 debug:1.0 eth:1.0 ethash:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0"
 	httpAPIs = "eth:1.0 net:1.0 rpc:1.0 web3:1.0"
 )
 
@@ -43,7 +43,7 @@ func TestConsoleWelcome(t *testing.T) {
 	// Start a geth console, make sure it's cleaned up and terminate the console
 	geth := runGeth(t,
 		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
-		"--etherbase", coinbase, "--shh",
+		"--etherbase", coinbase,
 		"console")
 
 	// Gather all the infos the welcome message needs to contain
@@ -83,11 +83,9 @@ func TestIPCAttachWelcome(t *testing.T) {
 		defer os.RemoveAll(ws)
 		ipc = filepath.Join(ws, "geth.ipc")
 	}
-	// Note: we need --shh because testAttachWelcome checks for default
-	// list of ipc modules and shh is included there.
 	geth := runGeth(t,
 		"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none",
-		"--etherbase", coinbase, "--shh", "--ipcpath", ipc)
+		"--etherbase", coinbase, "--ipcpath", ipc)
 
 	defer func() {
 		geth.Interrupt()

cmd/geth/usage.go

@@ -211,7 +211,7 @@ var AppHelpFlagGroups = []flags.FlagGroup{
 		Flags: metricsFlags,
 	},
 	{
-		Name:  "WHISPER (EXPERIMENTAL)",
+		Name:  "WHISPER (deprecated)",
 		Flags: whisperFlags,
 	},
 	{

cmd/utils/flags.go

@@ -63,7 +63,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/nat"
 	"github.com/ethereum/go-ethereum/p2p/netutil"
 	"github.com/ethereum/go-ethereum/params"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 	pcsclite "github.com/gballet/go-libpcsclite"
 	cli "gopkg.in/urfave/cli.v1"
 )
@@ -639,12 +638,12 @@ var (
 	WhisperMaxMessageSizeFlag = cli.IntFlag{
 		Name:  "shh.maxmessagesize",
 		Usage: "Max message size accepted",
-		Value: int(whisper.DefaultMaxMessageSize),
+		Value: 1024 * 1024,
 	}
 	WhisperMinPOWFlag = cli.Float64Flag{
 		Name:  "shh.pow",
 		Usage: "Minimum POW accepted",
-		Value: whisper.DefaultMinimumPoW,
+		Value: 0.2,
 	}
 	WhisperRestrictConnectionBetweenLightClientsFlag = cli.BoolFlag{
 		Name:  "shh.restrict-light",
@@ -1465,15 +1464,12 @@ func CheckExclusive(ctx *cli.Context, args ...interface{}) {
 }
 
 // SetShhConfig applies shh-related command line flags to the config.
-func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config) {
+func SetShhConfig(ctx *cli.Context, stack *node.Node) {
-	if ctx.GlobalIsSet(WhisperMaxMessageSizeFlag.Name) {
+	if ctx.GlobalIsSet(WhisperEnabledFlag.Name) ||
-		cfg.MaxMessageSize = uint32(ctx.GlobalUint(WhisperMaxMessageSizeFlag.Name))
+		ctx.GlobalIsSet(WhisperMaxMessageSizeFlag.Name) ||
-	}
+		ctx.GlobalIsSet(WhisperMinPOWFlag.Name) ||
-	if ctx.GlobalIsSet(WhisperMinPOWFlag.Name) {
+		ctx.GlobalIsSet(WhisperRestrictConnectionBetweenLightClientsFlag.Name) {
-		cfg.MinimumAcceptedPOW = ctx.GlobalFloat64(WhisperMinPOWFlag.Name)
+		log.Warn("Whisper support has been deprecated and the code has been moved to github.com/ethereum/whisper")
-	}
-	if ctx.GlobalIsSet(WhisperRestrictConnectionBetweenLightClientsFlag.Name) {
-		cfg.RestrictConnectionBetweenLightClients = true
 	}
 }
 
@@ -1697,13 +1693,6 @@ func RegisterEthService(stack *node.Node, cfg *eth.Config) ethapi.Backend {
 	}
 }
 
-// RegisterShhService configures Whisper and adds it to the given node.
-func RegisterShhService(stack *node.Node, cfg *whisper.Config) {
-	if _, err := whisper.New(stack, cfg); err != nil {
-		Fatalf("Failed to register the Whisper service: %v", err)
-	}
-}
-
 // RegisterEthStatsService configures the Ethereum Stats daemon and adds it to
 // the given node.
 func RegisterEthStatsService(stack *node.Node, backend ethapi.Backend, url string) {

cmd/wnode/main.go

@@ -1,773 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum 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 General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// This is a simple Whisper node. It could be used as a stand-alone bootstrap node.
-// Also, could be used for different test and diagnostics purposes.
-
-package main
-
-import (
-	"bufio"
-	"crypto/ecdsa"
-	crand "crypto/rand"
-	"crypto/sha512"
-	"encoding/binary"
-	"encoding/hex"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/console/prompt"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/whisper/mailserver"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
-	"golang.org/x/crypto/pbkdf2"
-)
-
-const quitCommand = "~Q"
-const entropySize = 32
-
-// singletons
-var (
-	server     *p2p.Server
-	shh        *whisper.Whisper
-	done       chan struct{}
-	mailServer mailserver.WMailServer
-	entropy    [entropySize]byte
-
-	input = bufio.NewReader(os.Stdin)
-)
-
-// encryption
-var (
-	symKey  []byte
-	pub     *ecdsa.PublicKey
-	asymKey *ecdsa.PrivateKey
-	nodeid  *ecdsa.PrivateKey
-	topic   whisper.TopicType
-
-	asymKeyID    string
-	asymFilterID string
-	symFilterID  string
-	symPass      string
-	msPassword   string
-)
-
-// cmd arguments
-var (
-	bootstrapMode  = flag.Bool("standalone", false, "boostrap node: don't initiate connection to peers, just wait for incoming connections")
-	forwarderMode  = flag.Bool("forwarder", false, "forwarder mode: only forward messages, neither encrypt nor decrypt messages")
-	mailServerMode = flag.Bool("mailserver", false, "mail server mode: delivers expired messages on demand")
-	requestMail    = flag.Bool("mailclient", false, "request expired messages from the bootstrap server")
-	asymmetricMode = flag.Bool("asym", false, "use asymmetric encryption")
-	generateKey    = flag.Bool("generatekey", false, "generate and show the private key")
-	fileExMode     = flag.Bool("fileexchange", false, "file exchange mode")
-	fileReader     = flag.Bool("filereader", false, "load and decrypt messages saved as files, display as plain text")
-	testMode       = flag.Bool("test", false, "use of predefined parameters for diagnostics (password, etc.)")
-	echoMode       = flag.Bool("echo", false, "echo mode: prints some arguments for diagnostics")
-
-	argVerbosity = flag.Int("verbosity", int(log.LvlError), "log verbosity level")
-	argTTL       = flag.Uint("ttl", 30, "time-to-live for messages in seconds")
-	argWorkTime  = flag.Uint("work", 5, "work time in seconds")
-	argMaxSize   = flag.Uint("maxsize", uint(whisper.DefaultMaxMessageSize), "max size of message")
-	argPoW       = flag.Float64("pow", whisper.DefaultMinimumPoW, "PoW for normal messages in float format (e.g. 2.7)")
-	argServerPoW = flag.Float64("mspow", whisper.DefaultMinimumPoW, "PoW requirement for Mail Server request")
-
-	argIP      = flag.String("ip", "", "IP address and port of this node (e.g. 127.0.0.1:30303)")
-	argPub     = flag.String("pub", "", "public key for asymmetric encryption")
-	argDBPath  = flag.String("dbpath", "", "path to the server's DB directory")
-	argIDFile  = flag.String("idfile", "", "file name with node id (private key)")
-	argEnode   = flag.String("boot", "", "bootstrap node you want to connect to (e.g. enode://e454......08d50@52.176.211.200:16428)")
-	argTopic   = flag.String("topic", "", "topic in hexadecimal format (e.g. 70a4beef)")
-	argSaveDir = flag.String("savedir", "", "directory where all incoming messages will be saved as files")
-)
-
-func main() {
-	processArgs()
-	initialize()
-	run()
-	shutdown()
-}
-
-func processArgs() {
-	flag.Parse()
-
-	if len(*argIDFile) > 0 {
-		var err error
-		nodeid, err = crypto.LoadECDSA(*argIDFile)
-		if err != nil {
-			utils.Fatalf("Failed to load file [%s]: %s.", *argIDFile, err)
-		}
-	}
-
-	const enodePrefix = "enode://"
-	if len(*argEnode) > 0 {
-		if (*argEnode)[:len(enodePrefix)] != enodePrefix {
-			*argEnode = enodePrefix + *argEnode
-		}
-	}
-
-	if len(*argTopic) > 0 {
-		x, err := hex.DecodeString(*argTopic)
-		if err != nil {
-			utils.Fatalf("Failed to parse the topic: %s", err)
-		}
-		topic = whisper.BytesToTopic(x)
-	}
-
-	if *asymmetricMode && len(*argPub) > 0 {
-		var err error
-		if pub, err = crypto.UnmarshalPubkey(common.FromHex(*argPub)); err != nil {
-			utils.Fatalf("invalid public key")
-		}
-	}
-
-	if len(*argSaveDir) > 0 {
-		if _, err := os.Stat(*argSaveDir); os.IsNotExist(err) {
-			utils.Fatalf("Download directory '%s' does not exist", *argSaveDir)
-		}
-	} else if *fileExMode {
-		utils.Fatalf("Parameter 'savedir' is mandatory for file exchange mode")
-	}
-
-	if *echoMode {
-		echo()
-	}
-}
-
-func echo() {
-	fmt.Printf("ttl = %d \n", *argTTL)
-	fmt.Printf("workTime = %d \n", *argWorkTime)
-	fmt.Printf("pow = %f \n", *argPoW)
-	fmt.Printf("mspow = %f \n", *argServerPoW)
-	fmt.Printf("ip = %s \n", *argIP)
-	fmt.Printf("pub = %s \n", hexutil.Encode(crypto.FromECDSAPub(pub)))
-	fmt.Printf("idfile = %s \n", *argIDFile)
-	fmt.Printf("dbpath = %s \n", *argDBPath)
-	fmt.Printf("boot = %s \n", *argEnode)
-}
-
-func initialize() {
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*argVerbosity), log.StreamHandler(os.Stderr, log.TerminalFormat(false))))
-
-	done = make(chan struct{})
-	var peers []*enode.Node
-	var err error
-
-	if *generateKey {
-		key, err := crypto.GenerateKey()
-		if err != nil {
-			utils.Fatalf("Failed to generate private key: %s", err)
-		}
-		k := hex.EncodeToString(crypto.FromECDSA(key))
-		fmt.Printf("Random private key: %s \n", k)
-		os.Exit(0)
-	}
-
-	if *testMode {
-		symPass = "wwww" // ascii code: 0x77777777
-		msPassword = "wwww"
-	}
-
-	if *bootstrapMode {
-		if len(*argIP) == 0 {
-			argIP = scanLineA("Please enter your IP and port (e.g. 127.0.0.1:30348): ")
-		}
-	} else if *fileReader {
-		*bootstrapMode = true
-	} else {
-		if len(*argEnode) == 0 {
-			argEnode = scanLineA("Please enter the peer's enode: ")
-		}
-		peer := enode.MustParse(*argEnode)
-		peers = append(peers, peer)
-	}
-
-	if *mailServerMode {
-		if len(msPassword) == 0 {
-			msPassword, err = prompt.Stdin.PromptPassword("Please enter the Mail Server password: ")
-			if err != nil {
-				utils.Fatalf("Failed to read Mail Server password: %s", err)
-			}
-		}
-	}
-
-	cfg := &whisper.Config{
-		MaxMessageSize:     uint32(*argMaxSize),
-		MinimumAcceptedPOW: *argPoW,
-	}
-	shh = whisper.StandaloneWhisperService(cfg)
-
-	if *argPoW != whisper.DefaultMinimumPoW {
-		err := shh.SetMinimumPoW(*argPoW)
-		if err != nil {
-			utils.Fatalf("Failed to set PoW: %s", err)
-		}
-	}
-
-	if uint32(*argMaxSize) != whisper.DefaultMaxMessageSize {
-		err := shh.SetMaxMessageSize(uint32(*argMaxSize))
-		if err != nil {
-			utils.Fatalf("Failed to set max message size: %s", err)
-		}
-	}
-
-	asymKeyID, err = shh.NewKeyPair()
-	if err != nil {
-		utils.Fatalf("Failed to generate a new key pair: %s", err)
-	}
-
-	asymKey, err = shh.GetPrivateKey(asymKeyID)
-	if err != nil {
-		utils.Fatalf("Failed to retrieve a new key pair: %s", err)
-	}
-
-	if nodeid == nil {
-		tmpID, err := shh.NewKeyPair()
-		if err != nil {
-			utils.Fatalf("Failed to generate a new key pair: %s", err)
-		}
-
-		nodeid, err = shh.GetPrivateKey(tmpID)
-		if err != nil {
-			utils.Fatalf("Failed to retrieve a new key pair: %s", err)
-		}
-	}
-
-	maxPeers := 80
-	if *bootstrapMode {
-		maxPeers = 800
-	}
-
-	_, err = crand.Read(entropy[:])
-	if err != nil {
-		utils.Fatalf("crypto/rand failed: %s", err)
-	}
-
-	if *mailServerMode {
-		shh.RegisterServer(&mailServer)
-		if err := mailServer.Init(shh, *argDBPath, msPassword, *argServerPoW); err != nil {
-			utils.Fatalf("Failed to init MailServer: %s", err)
-		}
-	}
-
-	server = &p2p.Server{
-		Config: p2p.Config{
-			PrivateKey:     nodeid,
-			MaxPeers:       maxPeers,
-			Name:           common.MakeName("wnode", "6.0"),
-			Protocols:      shh.Protocols(),
-			ListenAddr:     *argIP,
-			NAT:            nat.Any(),
-			BootstrapNodes: peers,
-			StaticNodes:    peers,
-			TrustedNodes:   peers,
-		},
-	}
-}
-
-func startServer() error {
-	err := server.Start()
-	if err != nil {
-		fmt.Printf("Failed to start Whisper peer: %s.", err)
-		return err
-	}
-
-	fmt.Printf("my public key: %s \n", hexutil.Encode(crypto.FromECDSAPub(&asymKey.PublicKey)))
-	fmt.Println(server.NodeInfo().Enode)
-
-	if *bootstrapMode {
-		configureNode()
-		fmt.Println("Bootstrap Whisper node started")
-	} else {
-		fmt.Println("Whisper node started")
-		// first see if we can establish connection, then ask for user input
-		waitForConnection(true)
-		configureNode()
-	}
-
-	if *fileExMode {
-		fmt.Printf("Please type the file name to be send. To quit type: '%s'\n", quitCommand)
-	} else if *fileReader {
-		fmt.Printf("Please type the file name to be decrypted. To quit type: '%s'\n", quitCommand)
-	} else if !*forwarderMode {
-		fmt.Printf("Please type the message. To quit type: '%s'\n", quitCommand)
-	}
-	return nil
-}
-
-func configureNode() {
-	var err error
-	var p2pAccept bool
-
-	if *forwarderMode {
-		return
-	}
-
-	if *asymmetricMode {
-		if len(*argPub) == 0 {
-			s := scanLine("Please enter the peer's public key: ")
-			b := common.FromHex(s)
-			if b == nil {
-				utils.Fatalf("Error: can not convert hexadecimal string")
-			}
-			if pub, err = crypto.UnmarshalPubkey(b); err != nil {
-				utils.Fatalf("Error: invalid peer public key")
-			}
-		}
-	}
-
-	if *requestMail {
-		p2pAccept = true
-		if len(msPassword) == 0 {
-			msPassword, err = prompt.Stdin.PromptPassword("Please enter the Mail Server password: ")
-			if err != nil {
-				utils.Fatalf("Failed to read Mail Server password: %s", err)
-			}
-		}
-	}
-
-	if !*asymmetricMode && !*forwarderMode {
-		if len(symPass) == 0 {
-			symPass, err = prompt.Stdin.PromptPassword("Please enter the password for symmetric encryption: ")
-			if err != nil {
-				utils.Fatalf("Failed to read password: %v", err)
-			}
-		}
-
-		symKeyID, err := shh.AddSymKeyFromPassword(symPass)
-		if err != nil {
-			utils.Fatalf("Failed to create symmetric key: %s", err)
-		}
-		symKey, err = shh.GetSymKey(symKeyID)
-		if err != nil {
-			utils.Fatalf("Failed to save symmetric key: %s", err)
-		}
-		if len(*argTopic) == 0 {
-			generateTopic([]byte(symPass))
-		}
-
-		fmt.Printf("Filter is configured for the topic: %x \n", topic)
-	}
-
-	if *mailServerMode {
-		if len(*argDBPath) == 0 {
-			argDBPath = scanLineA("Please enter the path to DB file: ")
-		}
-	}
-
-	symFilter := whisper.Filter{
-		KeySym:   symKey,
-		Topics:   [][]byte{topic[:]},
-		AllowP2P: p2pAccept,
-	}
-	symFilterID, err = shh.Subscribe(&symFilter)
-	if err != nil {
-		utils.Fatalf("Failed to install filter: %s", err)
-	}
-
-	asymFilter := whisper.Filter{
-		KeyAsym:  asymKey,
-		Topics:   [][]byte{topic[:]},
-		AllowP2P: p2pAccept,
-	}
-	asymFilterID, err = shh.Subscribe(&asymFilter)
-	if err != nil {
-		utils.Fatalf("Failed to install filter: %s", err)
-	}
-}
-
-func generateTopic(password []byte) {
-	x := pbkdf2.Key(password, password, 4096, 128, sha512.New)
-	for i := 0; i < len(x); i++ {
-		topic[i%whisper.TopicLength] ^= x[i]
-	}
-}
-
-func waitForConnection(timeout bool) {
-	var cnt int
-	var connected bool
-	for !connected {
-		time.Sleep(time.Millisecond * 50)
-		connected = server.PeerCount() > 0
-		if timeout {
-			cnt++
-			if cnt > 1000 {
-				utils.Fatalf("Timeout expired, failed to connect")
-			}
-		}
-	}
-
-	fmt.Println("Connected to peer.")
-}
-
-func run() {
-	err := startServer()
-	if err != nil {
-		return
-	}
-	defer server.Stop()
-	shh.Start()
-	defer shh.Stop()
-
-	if !*forwarderMode {
-		go messageLoop()
-	}
-
-	if *requestMail {
-		requestExpiredMessagesLoop()
-	} else if *fileExMode {
-		sendFilesLoop()
-	} else if *fileReader {
-		fileReaderLoop()
-	} else {
-		sendLoop()
-	}
-}
-
-func shutdown() {
-	close(done)
-	mailServer.Close()
-}
-
-func sendLoop() {
-	for {
-		s := scanLine("")
-		if s == quitCommand {
-			fmt.Println("Quit command received")
-			return
-		}
-		sendMsg([]byte(s))
-		if *asymmetricMode {
-			// print your own message for convenience,
-			// because in asymmetric mode it is impossible to decrypt it
-			timestamp := time.Now().Unix()
-			from := crypto.PubkeyToAddress(asymKey.PublicKey)
-			fmt.Printf("\n%d <%x>: %s\n", timestamp, from, s)
-		}
-	}
-}
-
-func sendFilesLoop() {
-	for {
-		s := scanLine("")
-		if s == quitCommand {
-			fmt.Println("Quit command received")
-			return
-		}
-		b, err := ioutil.ReadFile(s)
-		if err != nil {
-			fmt.Printf(">>> Error: %s \n", err)
-		} else {
-			h := sendMsg(b)
-			if (h == common.Hash{}) {
-				fmt.Printf(">>> Error: message was not sent \n")
-			} else {
-				timestamp := time.Now().Unix()
-				from := crypto.PubkeyToAddress(asymKey.PublicKey)
-				fmt.Printf("\n%d <%x>: sent message with hash %x\n", timestamp, from, h)
-			}
-		}
-	}
-}
-
-func fileReaderLoop() {
-	watcher1 := shh.GetFilter(symFilterID)
-	watcher2 := shh.GetFilter(asymFilterID)
-	if watcher1 == nil && watcher2 == nil {
-		fmt.Println("Error: neither symmetric nor asymmetric filter is installed")
-		return
-	}
-
-	for {
-		s := scanLine("")
-		if s == quitCommand {
-			fmt.Println("Quit command received")
-			return
-		}
-		raw, err := ioutil.ReadFile(s)
-		if err != nil {
-			fmt.Printf(">>> Error: %s \n", err)
-		} else {
-			env := whisper.Envelope{Data: raw} // the topic is zero
-			msg := env.Open(watcher1)          // force-open envelope regardless of the topic
-			if msg == nil {
-				msg = env.Open(watcher2)
-			}
-			if msg == nil {
-				fmt.Printf(">>> Error: failed to decrypt the message \n")
-			} else {
-				printMessageInfo(msg)
-			}
-		}
-	}
-}
-
-func scanLine(prompt string) string {
-	if len(prompt) > 0 {
-		fmt.Print(prompt)
-	}
-	txt, err := input.ReadString('\n')
-	if err != nil {
-		utils.Fatalf("input error: %s", err)
-	}
-	txt = strings.TrimRight(txt, "\n\r")
-	return txt
-}
-
-func scanLineA(prompt string) *string {
-	s := scanLine(prompt)
-	return &s
-}
-
-func scanUint(prompt string) uint32 {
-	s := scanLine(prompt)
-	i, err := strconv.Atoi(s)
-	if err != nil {
-		utils.Fatalf("Fail to parse the lower time limit: %s", err)
-	}
-	return uint32(i)
-}
-
-func sendMsg(payload []byte) common.Hash {
-	params := whisper.MessageParams{
-		Src:      asymKey,
-		Dst:      pub,
-		KeySym:   symKey,
-		Payload:  payload,
-		Topic:    topic,
-		TTL:      uint32(*argTTL),
-		PoW:      *argPoW,
-		WorkTime: uint32(*argWorkTime),
-	}
-
-	msg, err := whisper.NewSentMessage(&params)
-	if err != nil {
-		utils.Fatalf("failed to create new message: %s", err)
-	}
-
-	envelope, err := msg.Wrap(&params)
-	if err != nil {
-		fmt.Printf("failed to seal message: %v \n", err)
-		return common.Hash{}
-	}
-
-	err = shh.Send(envelope)
-	if err != nil {
-		fmt.Printf("failed to send message: %v \n", err)
-		return common.Hash{}
-	}
-
-	return envelope.Hash()
-}
-
-func messageLoop() {
-	sf := shh.GetFilter(symFilterID)
-	if sf == nil {
-		utils.Fatalf("symmetric filter is not installed")
-	}
-
-	af := shh.GetFilter(asymFilterID)
-	if af == nil {
-		utils.Fatalf("asymmetric filter is not installed")
-	}
-
-	ticker := time.NewTicker(time.Millisecond * 50)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			m1 := sf.Retrieve()
-			m2 := af.Retrieve()
-			messages := append(m1, m2...)
-			for _, msg := range messages {
-				reportedOnce := false
-				if !*fileExMode && len(msg.Payload) <= 2048 {
-					printMessageInfo(msg)
-					reportedOnce = true
-				}
-
-				// All messages are saved upon specifying argSaveDir.
-				// fileExMode only specifies how messages are displayed on the console after they are saved.
-				// if fileExMode == true, only the hashes are displayed, since messages might be too big.
-				if len(*argSaveDir) > 0 {
-					writeMessageToFile(*argSaveDir, msg, !reportedOnce)
-				}
-			}
-		case <-done:
-			return
-		}
-	}
-}
-
-func printMessageInfo(msg *whisper.ReceivedMessage) {
-	timestamp := fmt.Sprintf("%d", msg.Sent) // unix timestamp for diagnostics
-	text := string(msg.Payload)
-
-	var address common.Address
-	if msg.Src != nil {
-		address = crypto.PubkeyToAddress(*msg.Src)
-	}
-
-	if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) {
-		fmt.Printf("\n%s <%x>: %s\n", timestamp, address, text) // message from myself
-	} else {
-		fmt.Printf("\n%s [%x]: %s\n", timestamp, address, text) // message from a peer
-	}
-}
-
-func writeMessageToFile(dir string, msg *whisper.ReceivedMessage, show bool) {
-	if len(dir) == 0 {
-		return
-	}
-
-	timestamp := fmt.Sprintf("%d", msg.Sent)
-	name := fmt.Sprintf("%x", msg.EnvelopeHash)
-
-	var address common.Address
-	if msg.Src != nil {
-		address = crypto.PubkeyToAddress(*msg.Src)
-	}
-
-	env := shh.GetEnvelope(msg.EnvelopeHash)
-	if env == nil {
-		fmt.Printf("\nUnexpected error: envelope not found: %x\n", msg.EnvelopeHash)
-		return
-	}
-
-	// this is a sample code; uncomment if you don't want to save your own messages.
-	//if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) {
-	//	fmt.Printf("\n%s <%x>: message from myself received, not saved: '%s'\n", timestamp, address, name)
-	//	return
-	//}
-
-	fullpath := filepath.Join(dir, name)
-	err := ioutil.WriteFile(fullpath, env.Data, 0644)
-	if err != nil {
-		fmt.Printf("\n%s {%x}: message received but not saved: %s\n", timestamp, address, err)
-	} else if show {
-		fmt.Printf("\n%s {%x}: message received and saved as '%s' (%d bytes)\n", timestamp, address, name, len(env.Data))
-	}
-}
-
-func requestExpiredMessagesLoop() {
-	var key, peerID, bloom []byte
-	var timeLow, timeUpp uint32
-	var t string
-	var xt whisper.TopicType
-
-	keyID, err := shh.AddSymKeyFromPassword(msPassword)
-	if err != nil {
-		utils.Fatalf("Failed to create symmetric key for mail request: %s", err)
-	}
-	key, err = shh.GetSymKey(keyID)
-	if err != nil {
-		utils.Fatalf("Failed to save symmetric key for mail request: %s", err)
-	}
-	peerID = extractIDFromEnode(*argEnode)
-	shh.AllowP2PMessagesFromPeer(peerID)
-
-	for {
-		timeLow = scanUint("Please enter the lower limit of the time range (unix timestamp): ")
-		timeUpp = scanUint("Please enter the upper limit of the time range (unix timestamp): ")
-		t = scanLine("Enter the topic (hex). Press enter to request all messages, regardless of the topic: ")
-		if len(t) == whisper.TopicLength*2 {
-			x, err := hex.DecodeString(t)
-			if err != nil {
-				fmt.Printf("Failed to parse the topic: %s \n", err)
-				continue
-			}
-			xt = whisper.BytesToTopic(x)
-			bloom = whisper.TopicToBloom(xt)
-			obfuscateBloom(bloom)
-		} else if len(t) == 0 {
-			bloom = whisper.MakeFullNodeBloom()
-		} else {
-			fmt.Println("Error: topic is invalid, request aborted")
-			continue
-		}
-
-		if timeUpp == 0 {
-			timeUpp = 0xFFFFFFFF
-		}
-
-		data := make([]byte, 8, 8+whisper.BloomFilterSize)
-		binary.BigEndian.PutUint32(data, timeLow)
-		binary.BigEndian.PutUint32(data[4:], timeUpp)
-		data = append(data, bloom...)
-
-		var params whisper.MessageParams
-		params.PoW = *argServerPoW
-		params.Payload = data
-		params.KeySym = key
-		params.Src = asymKey
-		params.WorkTime = 5
-
-		msg, err := whisper.NewSentMessage(&params)
-		if err != nil {
-			utils.Fatalf("failed to create new message: %s", err)
-		}
-		env, err := msg.Wrap(&params)
-		if err != nil {
-			utils.Fatalf("Wrap failed: %s", err)
-		}
-
-		err = shh.RequestHistoricMessages(peerID, env)
-		if err != nil {
-			utils.Fatalf("Failed to send P2P message: %s", err)
-		}
-
-		time.Sleep(time.Second * 5)
-	}
-}
-
-func extractIDFromEnode(s string) []byte {
-	n, err := enode.Parse(enode.ValidSchemes, s)
-	if err != nil {
-		utils.Fatalf("Failed to parse node: %s", err)
-	}
-	return n.ID().Bytes()
-}
-
-// obfuscateBloom adds 16 random bits to the bloom
-// filter, in order to obfuscate the containing topics.
-// it does so deterministically within every session.
-// despite additional bits, it will match on average
-// 32000 times less messages than full node's bloom filter.
-func obfuscateBloom(bloom []byte) {
-	const half = entropySize / 2
-	for i := 0; i < half; i++ {
-		x := int(entropy[i])
-		if entropy[half+i] < 128 {
-			x += 256
-		}
-
-		bloom[x/8] = 1 << uint(x%8) // set the bit number X
-	}
-}

mobile/geth.go

@@ -35,7 +35,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/nat"
 	"github.com/ethereum/go-ethereum/params"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 )
 
 // NodeConfig represents the collection of configuration values to fine tune the Geth
@@ -71,9 +70,6 @@ type NodeConfig struct {
 	// It has the form "nodename:secret@host:port"
 	EthereumNetStats string
 
-	// WhisperEnabled specifies whether the node should run the Whisper protocol.
-	WhisperEnabled bool
-
 	// Listening address of pprof server.
 	PprofAddress string
 }
@@ -186,12 +182,6 @@ func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) {
 			}
 		}
 	}
-	// Register the Whisper protocol if requested
-	if config.WhisperEnabled {
-		if _, err := whisper.New(rawStack, &whisper.DefaultConfig); err != nil {
-			return nil, fmt.Errorf("whisper init: %v", err)
-		}
-	}
 	return &Node{rawStack}, nil
 }
 

mobile/shhclient.go

@@ -1,195 +0,0 @@
-// 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/>.
-
-// Contains a wrapper for the Whisper client.
-
-package geth
-
-import (
-	"github.com/ethereum/go-ethereum/whisper/shhclient"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
-)
-
-// WhisperClient provides access to the Ethereum APIs.
-type WhisperClient struct {
-	client *shhclient.Client
-}
-
-// NewWhisperClient connects a client to the given URL.
-func NewWhisperClient(rawurl string) (client *WhisperClient, _ error) {
-	rawClient, err := shhclient.Dial(rawurl)
-	return &WhisperClient{rawClient}, err
-}
-
-// GetVersion returns the Whisper sub-protocol version.
-func (wc *WhisperClient) GetVersion(ctx *Context) (version string, _ error) {
-	return wc.client.Version(ctx.context)
-}
-
-// Info returns diagnostic information about the whisper node.
-func (wc *WhisperClient) GetInfo(ctx *Context) (info *Info, _ error) {
-	rawInfo, err := wc.client.Info(ctx.context)
-	return &Info{&rawInfo}, err
-}
-
-// SetMaxMessageSize sets the maximal message size allowed by this node. Incoming
-// and outgoing messages with a larger size will be rejected. Whisper message size
-// can never exceed the limit imposed by the underlying P2P protocol (10 Mb).
-func (wc *WhisperClient) SetMaxMessageSize(ctx *Context, size int32) error {
-	return wc.client.SetMaxMessageSize(ctx.context, uint32(size))
-}
-
-// SetMinimumPoW (experimental) sets the minimal PoW required by this node.
-// This experimental function was introduced for the future dynamic adjustment of
-// PoW requirement. If the node is overwhelmed with messages, it should raise the
-// PoW requirement and notify the peers. The new value should be set relative to
-// the old value (e.g. double). The old value could be obtained via shh_info call.
-func (wc *WhisperClient) SetMinimumPoW(ctx *Context, pow float64) error {
-	return wc.client.SetMinimumPoW(ctx.context, pow)
-}
-
-// Marks specific peer trusted, which will allow it to send historic (expired) messages.
-// Note This function is not adding new nodes, the node needs to exists as a peer.
-func (wc *WhisperClient) MarkTrustedPeer(ctx *Context, enode string) error {
-	return wc.client.MarkTrustedPeer(ctx.context, enode)
-}
-
-// NewKeyPair generates a new public and private key pair for message decryption and encryption.
-// It returns an identifier that can be used to refer to the key.
-func (wc *WhisperClient) NewKeyPair(ctx *Context) (string, error) {
-	return wc.client.NewKeyPair(ctx.context)
-}
-
-// AddPrivateKey stored the key pair, and returns its ID.
-func (wc *WhisperClient) AddPrivateKey(ctx *Context, key []byte) (string, error) {
-	return wc.client.AddPrivateKey(ctx.context, key)
-}
-
-// DeleteKeyPair delete the specifies key.
-func (wc *WhisperClient) DeleteKeyPair(ctx *Context, id string) (string, error) {
-	return wc.client.DeleteKeyPair(ctx.context, id)
-}
-
-// HasKeyPair returns an indication if the node has a private key or
-// key pair matching the given ID.
-func (wc *WhisperClient) HasKeyPair(ctx *Context, id string) (bool, error) {
-	return wc.client.HasKeyPair(ctx.context, id)
-}
-
-// GetPublicKey return the public key for a key ID.
-func (wc *WhisperClient) GetPublicKey(ctx *Context, id string) ([]byte, error) {
-	return wc.client.PublicKey(ctx.context, id)
-}
-
-// GetPrivateKey return the private key for a key ID.
-func (wc *WhisperClient) GetPrivateKey(ctx *Context, id string) ([]byte, error) {
-	return wc.client.PrivateKey(ctx.context, id)
-}
-
-// NewSymmetricKey generates a random symmetric key and returns its identifier.
-// Can be used encrypting and decrypting messages where the key is known to both parties.
-func (wc *WhisperClient) NewSymmetricKey(ctx *Context) (string, error) {
-	return wc.client.NewSymmetricKey(ctx.context)
-}
-
-// AddSymmetricKey stores the key, and returns its identifier.
-func (wc *WhisperClient) AddSymmetricKey(ctx *Context, key []byte) (string, error) {
-	return wc.client.AddSymmetricKey(ctx.context, key)
-}
-
-// GenerateSymmetricKeyFromPassword generates the key from password, stores it, and returns its identifier.
-func (wc *WhisperClient) GenerateSymmetricKeyFromPassword(ctx *Context, passwd string) (string, error) {
-	return wc.client.GenerateSymmetricKeyFromPassword(ctx.context, passwd)
-}
-
-// HasSymmetricKey returns an indication if the key associated with the given id is stored in the node.
-func (wc *WhisperClient) HasSymmetricKey(ctx *Context, id string) (bool, error) {
-	return wc.client.HasSymmetricKey(ctx.context, id)
-}
-
-// GetSymmetricKey returns the symmetric key associated with the given identifier.
-func (wc *WhisperClient) GetSymmetricKey(ctx *Context, id string) ([]byte, error) {
-	return wc.client.GetSymmetricKey(ctx.context, id)
-}
-
-// DeleteSymmetricKey deletes the symmetric key associated with the given identifier.
-func (wc *WhisperClient) DeleteSymmetricKey(ctx *Context, id string) error {
-	return wc.client.DeleteSymmetricKey(ctx.context, id)
-}
-
-// Post a message onto the network.
-func (wc *WhisperClient) Post(ctx *Context, message *NewMessage) (string, error) {
-	return wc.client.Post(ctx.context, *message.newMessage)
-}
-
-// NewHeadHandler is a client-side subscription callback to invoke on events and
-// subscription failure.
-type NewMessageHandler interface {
-	OnNewMessage(message *Message)
-	OnError(failure string)
-}
-
-// SubscribeMessages subscribes to messages that match the given criteria. This method
-// is only supported on bi-directional connections such as websockets and IPC.
-// NewMessageFilter uses polling and is supported over HTTP.
-func (wc *WhisperClient) SubscribeMessages(ctx *Context, criteria *Criteria, handler NewMessageHandler, buffer int) (*Subscription, error) {
-	// Subscribe to the event internally
-	ch := make(chan *whisper.Message, buffer)
-	rawSub, err := wc.client.SubscribeMessages(ctx.context, *criteria.criteria, ch)
-	if err != nil {
-		return nil, err
-	}
-	// Start up a dispatcher to feed into the callback
-	go func() {
-		for {
-			select {
-			case message := <-ch:
-				handler.OnNewMessage(&Message{message})
-
-			case err := <-rawSub.Err():
-				if err != nil {
-					handler.OnError(err.Error())
-				}
-				return
-			}
-		}
-	}()
-	return &Subscription{rawSub}, nil
-}
-
-// NewMessageFilter creates a filter within the node. This filter can be used to poll
-// for new messages (see FilterMessages) that satisfy the given criteria. A filter can
-// timeout when it was polled for in whisper.filterTimeout.
-func (wc *WhisperClient) NewMessageFilter(ctx *Context, criteria *Criteria) (string, error) {
-	return wc.client.NewMessageFilter(ctx.context, *criteria.criteria)
-}
-
-// DeleteMessageFilter removes the filter associated with the given id.
-func (wc *WhisperClient) DeleteMessageFilter(ctx *Context, id string) error {
-	return wc.client.DeleteMessageFilter(ctx.context, id)
-}
-
-// GetFilterMessages retrieves all messages that are received between the last call to
-// this function and match the criteria that where given when the filter was created.
-func (wc *WhisperClient) GetFilterMessages(ctx *Context, id string) (*Messages, error) {
-	rawFilterMessages, err := wc.client.FilterMessages(ctx.context, id)
-	if err != nil {
-		return nil, err
-	}
-	res := make([]*whisper.Message, len(rawFilterMessages))
-	copy(res, rawFilterMessages)
-	return &Messages{res}, nil
-}

mobile/types.go

@@ -26,7 +26,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rlp"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 )
 
 // A Nonce is a 64-bit hash which proves (combined with the mix-hash) that
@@ -345,95 +344,3 @@ func (r *Receipt) GetLogs() *Logs               { return &Logs{r.receipt.Logs} }
 func (r *Receipt) GetTxHash() *Hash             { return &Hash{r.receipt.TxHash} }
 func (r *Receipt) GetContractAddress() *Address { return &Address{r.receipt.ContractAddress} }
 func (r *Receipt) GetGasUsed() int64            { return int64(r.receipt.GasUsed) }
-
-// Info represents a diagnostic information about the whisper node.
-type Info struct {
-	info *whisper.Info
-}
-
-// NewMessage represents a new whisper message that is posted through the RPC.
-type NewMessage struct {
-	newMessage *whisper.NewMessage
-}
-
-func NewNewMessage() *NewMessage {
-	nm := &NewMessage{
-		newMessage: new(whisper.NewMessage),
-	}
-	return nm
-}
-
-func (nm *NewMessage) GetSymKeyID() string         { return nm.newMessage.SymKeyID }
-func (nm *NewMessage) SetSymKeyID(symKeyID string) { nm.newMessage.SymKeyID = symKeyID }
-func (nm *NewMessage) GetPublicKey() []byte        { return nm.newMessage.PublicKey }
-func (nm *NewMessage) SetPublicKey(publicKey []byte) {
-	nm.newMessage.PublicKey = common.CopyBytes(publicKey)
-}
-func (nm *NewMessage) GetSig() string                  { return nm.newMessage.Sig }
-func (nm *NewMessage) SetSig(sig string)               { nm.newMessage.Sig = sig }
-func (nm *NewMessage) GetTTL() int64                   { return int64(nm.newMessage.TTL) }
-func (nm *NewMessage) SetTTL(ttl int64)                { nm.newMessage.TTL = uint32(ttl) }
-func (nm *NewMessage) GetPayload() []byte              { return nm.newMessage.Payload }
-func (nm *NewMessage) SetPayload(payload []byte)       { nm.newMessage.Payload = common.CopyBytes(payload) }
-func (nm *NewMessage) GetPowTime() int64               { return int64(nm.newMessage.PowTime) }
-func (nm *NewMessage) SetPowTime(powTime int64)        { nm.newMessage.PowTime = uint32(powTime) }
-func (nm *NewMessage) GetPowTarget() float64           { return nm.newMessage.PowTarget }
-func (nm *NewMessage) SetPowTarget(powTarget float64)  { nm.newMessage.PowTarget = powTarget }
-func (nm *NewMessage) GetTargetPeer() string           { return nm.newMessage.TargetPeer }
-func (nm *NewMessage) SetTargetPeer(targetPeer string) { nm.newMessage.TargetPeer = targetPeer }
-func (nm *NewMessage) GetTopic() []byte                { return nm.newMessage.Topic[:] }
-func (nm *NewMessage) SetTopic(topic []byte)           { nm.newMessage.Topic = whisper.BytesToTopic(topic) }
-
-// Message represents a whisper message.
-type Message struct {
-	message *whisper.Message
-}
-
-func (m *Message) GetSig() []byte      { return m.message.Sig }
-func (m *Message) GetTTL() int64       { return int64(m.message.TTL) }
-func (m *Message) GetTimestamp() int64 { return int64(m.message.Timestamp) }
-func (m *Message) GetPayload() []byte  { return m.message.Payload }
-func (m *Message) GetPoW() float64     { return m.message.PoW }
-func (m *Message) GetHash() []byte     { return m.message.Hash }
-func (m *Message) GetDst() []byte      { return m.message.Dst }
-
-// Messages represents an array of messages.
-type Messages struct {
-	messages []*whisper.Message
-}
-
-// Size returns the number of messages in the slice.
-func (m *Messages) Size() int {
-	return len(m.messages)
-}
-
-// Get returns the message at the given index from the slice.
-func (m *Messages) Get(index int) (message *Message, _ error) {
-	if index < 0 || index >= len(m.messages) {
-		return nil, errors.New("index out of bounds")
-	}
-	return &Message{m.messages[index]}, nil
-}
-
-// Criteria holds various filter options for inbound messages.
-type Criteria struct {
-	criteria *whisper.Criteria
-}
-
-func NewCriteria(topic []byte) *Criteria {
-	c := &Criteria{
-		criteria: new(whisper.Criteria),
-	}
-	encodedTopic := whisper.BytesToTopic(topic)
-	c.criteria.Topics = []whisper.TopicType{encodedTopic}
-	return c
-}
-
-func (c *Criteria) GetSymKeyID() string                 { return c.criteria.SymKeyID }
-func (c *Criteria) SetSymKeyID(symKeyID string)         { c.criteria.SymKeyID = symKeyID }
-func (c *Criteria) GetPrivateKeyID() string             { return c.criteria.PrivateKeyID }
-func (c *Criteria) SetPrivateKeyID(privateKeyID string) { c.criteria.PrivateKeyID = privateKeyID }
-func (c *Criteria) GetSig() []byte                      { return c.criteria.Sig }
-func (c *Criteria) SetSig(sig []byte)                   { c.criteria.Sig = common.CopyBytes(sig) }
-func (c *Criteria) GetMinPow() float64                  { return c.criteria.MinPow }
-func (c *Criteria) SetMinPow(pow float64)               { c.criteria.MinPow = pow }

tests/fuzzers/whisperv6/whisper-fuzzer.go

@@ -1,90 +0,0 @@
-// Copyright 2019 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/>.
-
-package whisperv6
-
-import (
-	"bytes"
-
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/whisper/whisperv6"
-)
-
-type MessageParams struct {
-	Topic    whisperv6.TopicType
-	WorkTime uint32
-	TTL      uint32
-	KeySym   []byte
-	Payload  []byte
-}
-
-//export fuzzer_entry
-func Fuzz(input []byte) int {
-
-	var paramsDecoded MessageParams
-	err := rlp.DecodeBytes(input, &paramsDecoded)
-	if err != nil {
-		return 0
-	}
-	var params whisperv6.MessageParams
-	params.KeySym = make([]byte, 32)
-	if len(paramsDecoded.KeySym) <= 32 {
-		copy(params.KeySym, paramsDecoded.KeySym)
-	}
-	if input[0] == 255 {
-		params.PoW = 0.01
-		params.WorkTime = 1
-	} else {
-		params.PoW = 0
-		params.WorkTime = 0
-	}
-	params.TTL = paramsDecoded.TTL
-	params.Payload = paramsDecoded.Payload
-	text := make([]byte, 0, 512)
-	text = append(text, params.Payload...)
-	params.Topic = paramsDecoded.Topic
-	params.Src, err = crypto.GenerateKey()
-	if err != nil {
-		return 0
-	}
-	msg, err := whisperv6.NewSentMessage(&params)
-	if err != nil {
-		panic(err)
-		//return
-	}
-	env, err := msg.Wrap(&params)
-	if err != nil {
-		panic(err)
-	}
-	decrypted, err := env.OpenSymmetric(params.KeySym)
-	if err != nil {
-		panic(err)
-	}
-	if !decrypted.ValidateAndParse() {
-		panic("ValidateAndParse failed")
-	}
-	if !bytes.Equal(text, decrypted.Payload) {
-		panic("text != decrypted.Payload")
-	}
-	if len(decrypted.Signature) != 65 {
-		panic("Unexpected signature length")
-	}
-	if !whisperv6.IsPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
-		panic("Unexpected public key")
-	}
-	return 0
-}

whisper/mailserver/mailserver.go

@@ -1,209 +0,0 @@
-// Copyright 2017 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/>.
-
-// Package mailserver provides a naive, example mailserver implementation
-package mailserver
-
-import (
-	"encoding/binary"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/rlp"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/errors"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-// WMailServer represents the state data of the mailserver.
-type WMailServer struct {
-	db  *leveldb.DB
-	w   *whisper.Whisper
-	pow float64
-	key []byte
-}
-
-type DBKey struct {
-	timestamp uint32
-	hash      common.Hash
-	raw       []byte
-}
-
-// NewDbKey is a helper function that creates a levelDB
-// key from a hash and an integer.
-func NewDbKey(t uint32, h common.Hash) *DBKey {
-	const sz = common.HashLength + 4
-	var k DBKey
-	k.timestamp = t
-	k.hash = h
-	k.raw = make([]byte, sz)
-	binary.BigEndian.PutUint32(k.raw, k.timestamp)
-	copy(k.raw[4:], k.hash[:])
-	return &k
-}
-
-// Init initializes the mail server.
-func (s *WMailServer) Init(shh *whisper.Whisper, path string, password string, pow float64) error {
-	var err error
-	if len(path) == 0 {
-		return fmt.Errorf("DB file is not specified")
-	}
-
-	if len(password) == 0 {
-		return fmt.Errorf("password is not specified")
-	}
-
-	s.db, err = leveldb.OpenFile(path, &opt.Options{OpenFilesCacheCapacity: 32})
-	if _, iscorrupted := err.(*errors.ErrCorrupted); iscorrupted {
-		s.db, err = leveldb.RecoverFile(path, nil)
-	}
-	if err != nil {
-		return fmt.Errorf("open DB file: %s", err)
-	}
-
-	s.w = shh
-	s.pow = pow
-
-	MailServerKeyID, err := s.w.AddSymKeyFromPassword(password)
-	if err != nil {
-		return fmt.Errorf("create symmetric key: %s", err)
-	}
-	s.key, err = s.w.GetSymKey(MailServerKeyID)
-	if err != nil {
-		return fmt.Errorf("save symmetric key: %s", err)
-	}
-	return nil
-}
-
-// Close cleans up before shutdown.
-func (s *WMailServer) Close() {
-	if s.db != nil {
-		s.db.Close()
-	}
-}
-
-// Archive stores the
-func (s *WMailServer) Archive(env *whisper.Envelope) {
-	key := NewDbKey(env.Expiry-env.TTL, env.Hash())
-	rawEnvelope, err := rlp.EncodeToBytes(env)
-	if err != nil {
-		log.Error(fmt.Sprintf("rlp.EncodeToBytes failed: %s", err))
-	} else {
-		err = s.db.Put(key.raw, rawEnvelope, nil)
-		if err != nil {
-			log.Error(fmt.Sprintf("Writing to DB failed: %s", err))
-		}
-	}
-}
-
-// DeliverMail responds with saved messages upon request by the
-// messages' owner.
-func (s *WMailServer) DeliverMail(peer *whisper.Peer, request *whisper.Envelope) {
-	if peer == nil {
-		log.Error("Whisper peer is nil")
-		return
-	}
-
-	ok, lower, upper, bloom := s.validateRequest(peer.ID(), request)
-	if ok {
-		s.processRequest(peer, lower, upper, bloom)
-	}
-}
-
-func (s *WMailServer) processRequest(peer *whisper.Peer, lower, upper uint32, bloom []byte) []*whisper.Envelope {
-	ret := make([]*whisper.Envelope, 0)
-	var err error
-	var zero common.Hash
-	kl := NewDbKey(lower, zero)
-	ku := NewDbKey(upper+1, zero) // LevelDB is exclusive, while the Whisper API is inclusive
-	i := s.db.NewIterator(&util.Range{Start: kl.raw, Limit: ku.raw}, nil)
-	defer i.Release()
-
-	for i.Next() {
-		var envelope whisper.Envelope
-		err = rlp.DecodeBytes(i.Value(), &envelope)
-		if err != nil {
-			log.Error(fmt.Sprintf("RLP decoding failed: %s", err))
-		}
-
-		if whisper.BloomFilterMatch(bloom, envelope.Bloom()) {
-			if peer == nil {
-				// used for test purposes
-				ret = append(ret, &envelope)
-			} else {
-				err = s.w.SendP2PDirect(peer, &envelope)
-				if err != nil {
-					log.Error(fmt.Sprintf("Failed to send direct message to peer: %s", err))
-					return nil
-				}
-			}
-		}
-	}
-
-	err = i.Error()
-	if err != nil {
-		log.Error(fmt.Sprintf("Level DB iterator error: %s", err))
-	}
-
-	return ret
-}
-
-func (s *WMailServer) validateRequest(peerID []byte, request *whisper.Envelope) (bool, uint32, uint32, []byte) {
-	if s.pow > 0.0 && request.PoW() < s.pow {
-		return false, 0, 0, nil
-	}
-
-	f := whisper.Filter{KeySym: s.key}
-	decrypted := request.Open(&f)
-	if decrypted == nil {
-		log.Warn("Failed to decrypt p2p request")
-		return false, 0, 0, nil
-	}
-
-	src := crypto.FromECDSAPub(decrypted.Src)
-	if len(src)-len(peerID) == 1 {
-		src = src[1:]
-	}
-
-	// if you want to check the signature, you can do it here. e.g.:
-	// if !bytes.Equal(peerID, src) {
-	if src == nil {
-		log.Warn("Wrong signature of p2p request")
-		return false, 0, 0, nil
-	}
-
-	var bloom []byte
-	payloadSize := len(decrypted.Payload)
-	if payloadSize < 8 {
-		log.Warn("Undersized p2p request")
-		return false, 0, 0, nil
-	} else if payloadSize == 8 {
-		bloom = whisper.MakeFullNodeBloom()
-	} else if payloadSize < 8+whisper.BloomFilterSize {
-		log.Warn("Undersized bloom filter in p2p request")
-		return false, 0, 0, nil
-	} else {
-		bloom = decrypted.Payload[8 : 8+whisper.BloomFilterSize]
-	}
-
-	lower := binary.BigEndian.Uint32(decrypted.Payload[:4])
-	upper := binary.BigEndian.Uint32(decrypted.Payload[4:8])
-	return true, lower, upper, bloom
-}

whisper/mailserver/server_test.go

@@ -1,235 +0,0 @@
-// Copyright 2017 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/>.
-
-package mailserver
-
-import (
-	"bytes"
-	"crypto/ecdsa"
-	"encoding/binary"
-	"io/ioutil"
-	"math/rand"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/node"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
-)
-
-const powRequirement = 0.00001
-
-var keyID string
-var shh *whisper.Whisper
-var seed = time.Now().Unix()
-
-type ServerTestParams struct {
-	topic whisper.TopicType
-	low   uint32
-	upp   uint32
-	key   *ecdsa.PrivateKey
-}
-
-func assert(statement bool, text string, t *testing.T) {
-	if !statement {
-		t.Fatal(text)
-	}
-}
-
-func TestDBKey(t *testing.T) {
-	var h common.Hash
-	i := uint32(time.Now().Unix())
-	k := NewDbKey(i, h)
-	assert(len(k.raw) == common.HashLength+4, "wrong DB key length", t)
-	assert(byte(i%0x100) == k.raw[3], "raw representation should be big endian", t)
-	assert(byte(i/0x1000000) == k.raw[0], "big endian expected", t)
-}
-
-func generateEnvelope(t *testing.T) *whisper.Envelope {
-	h := crypto.Keccak256Hash([]byte("test sample data"))
-	params := &whisper.MessageParams{
-		KeySym:   h[:],
-		Topic:    whisper.TopicType{0x1F, 0x7E, 0xA1, 0x7F},
-		Payload:  []byte("test payload"),
-		PoW:      powRequirement,
-		WorkTime: 2,
-	}
-
-	msg, err := whisper.NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed to wrap with seed %d: %s.", seed, err)
-	}
-	return env
-}
-
-func TestMailServer(t *testing.T) {
-	const password = "password_for_this_test"
-	const dbPath = "whisper-server-test"
-
-	dir, err := ioutil.TempDir("", dbPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var server WMailServer
-
-	stack, w := newNode(t)
-	defer stack.Close()
-	shh = w
-
-	shh.RegisterServer(&server)
-
-	err = server.Init(shh, dir, password, powRequirement)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer server.Close()
-
-	keyID, err = shh.AddSymKeyFromPassword(password)
-	if err != nil {
-		t.Fatalf("Failed to create symmetric key for mail request: %s", err)
-	}
-
-	rand.Seed(seed)
-	env := generateEnvelope(t)
-	server.Archive(env)
-	deliverTest(t, &server, env)
-}
-
-func deliverTest(t *testing.T, server *WMailServer, env *whisper.Envelope) {
-	id, err := shh.NewKeyPair()
-	if err != nil {
-		t.Fatalf("failed to generate new key pair with seed %d: %s.", seed, err)
-	}
-	testPeerID, err := shh.GetPrivateKey(id)
-	if err != nil {
-		t.Fatalf("failed to retrieve new key pair with seed %d: %s.", seed, err)
-	}
-	birth := env.Expiry - env.TTL
-	p := &ServerTestParams{
-		topic: env.Topic,
-		low:   birth - 1,
-		upp:   birth + 1,
-		key:   testPeerID,
-	}
-
-	singleRequest(t, server, env, p, true)
-
-	p.low, p.upp = birth+1, 0xffffffff
-	singleRequest(t, server, env, p, false)
-
-	p.low, p.upp = 0, birth-1
-	singleRequest(t, server, env, p, false)
-
-	p.low = birth - 1
-	p.upp = birth + 1
-	p.topic[0] = 0xFF
-	singleRequest(t, server, env, p, false)
-}
-
-func singleRequest(t *testing.T, server *WMailServer, env *whisper.Envelope, p *ServerTestParams, expect bool) {
-	request := createRequest(t, p)
-	src := crypto.FromECDSAPub(&p.key.PublicKey)
-	ok, lower, upper, bloom := server.validateRequest(src, request)
-	if !ok {
-		t.Fatalf("request validation failed, seed: %d.", seed)
-	}
-	if lower != p.low {
-		t.Fatalf("request validation failed (lower bound), seed: %d.", seed)
-	}
-	if upper != p.upp {
-		t.Fatalf("request validation failed (upper bound), seed: %d.", seed)
-	}
-	expectedBloom := whisper.TopicToBloom(p.topic)
-	if !bytes.Equal(bloom, expectedBloom) {
-		t.Fatalf("request validation failed (topic), seed: %d.", seed)
-	}
-
-	var exist bool
-	mail := server.processRequest(nil, p.low, p.upp, bloom)
-	for _, msg := range mail {
-		if msg.Hash() == env.Hash() {
-			exist = true
-			break
-		}
-	}
-
-	if exist != expect {
-		t.Fatalf("error: exist = %v, seed: %d.", exist, seed)
-	}
-
-	src[0]++
-	ok, lower, upper, _ = server.validateRequest(src, request)
-	if !ok {
-		// request should be valid regardless of signature
-		t.Fatalf("request validation false negative, seed: %d (lower: %d, upper: %d).", seed, lower, upper)
-	}
-}
-
-func createRequest(t *testing.T, p *ServerTestParams) *whisper.Envelope {
-	bloom := whisper.TopicToBloom(p.topic)
-	data := make([]byte, 8)
-	binary.BigEndian.PutUint32(data, p.low)
-	binary.BigEndian.PutUint32(data[4:], p.upp)
-	data = append(data, bloom...)
-
-	key, err := shh.GetSymKey(keyID)
-	if err != nil {
-		t.Fatalf("failed to retrieve sym key with seed %d: %s.", seed, err)
-	}
-
-	params := &whisper.MessageParams{
-		KeySym:   key,
-		Topic:    p.topic,
-		Payload:  data,
-		PoW:      powRequirement * 2,
-		WorkTime: 2,
-		Src:      p.key,
-	}
-
-	msg, err := whisper.NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed to wrap with seed %d: %s.", seed, err)
-	}
-	return env
-}
-
-// newNode creates a new node using a default config and
-// creates and registers a new Whisper service on it.
-func newNode(t *testing.T) (*node.Node, *whisper.Whisper) {
-	stack, err := node.New(&node.DefaultConfig)
-	if err != nil {
-		t.Fatalf("could not create new node: %v", err)
-	}
-	w, err := whisper.New(stack, &whisper.DefaultConfig)
-	if err != nil {
-		t.Fatalf("could not create new whisper service: %v", err)
-	}
-	err = stack.Start()
-	if err != nil {
-		t.Fatalf("could not start node: %v", err)
-	}
-	return stack, w
-}

whisper/shhclient/client.go

@@ -1,193 +0,0 @@
-// Copyright 2017 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/>.
-
-package shhclient
-
-import (
-	"context"
-
-	ethereum "github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/rpc"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
-)
-
-// Client defines typed wrappers for the Whisper v6 RPC API.
-type Client struct {
-	c *rpc.Client
-}
-
-// Dial connects a client to the given URL.
-func Dial(rawurl string) (*Client, error) {
-	c, err := rpc.Dial(rawurl)
-	if err != nil {
-		return nil, err
-	}
-	return NewClient(c), nil
-}
-
-// NewClient creates a client that uses the given RPC client.
-func NewClient(c *rpc.Client) *Client {
-	return &Client{c}
-}
-
-// Version returns the Whisper sub-protocol version.
-func (sc *Client) Version(ctx context.Context) (string, error) {
-	var result string
-	err := sc.c.CallContext(ctx, &result, "shh_version")
-	return result, err
-}
-
-// Info returns diagnostic information about the whisper node.
-func (sc *Client) Info(ctx context.Context) (whisper.Info, error) {
-	var info whisper.Info
-	err := sc.c.CallContext(ctx, &info, "shh_info")
-	return info, err
-}
-
-// SetMaxMessageSize sets the maximal message size allowed by this node. Incoming
-// and outgoing messages with a larger size will be rejected. Whisper message size
-// can never exceed the limit imposed by the underlying P2P protocol (10 Mb).
-func (sc *Client) SetMaxMessageSize(ctx context.Context, size uint32) error {
-	var ignored bool
-	return sc.c.CallContext(ctx, &ignored, "shh_setMaxMessageSize", size)
-}
-
-// SetMinimumPoW (experimental) sets the minimal PoW required by this node.
-// This experimental function was introduced for the future dynamic adjustment of
-// PoW requirement. If the node is overwhelmed with messages, it should raise the
-// PoW requirement and notify the peers. The new value should be set relative to
-// the old value (e.g. double). The old value could be obtained via shh_info call.
-func (sc *Client) SetMinimumPoW(ctx context.Context, pow float64) error {
-	var ignored bool
-	return sc.c.CallContext(ctx, &ignored, "shh_setMinPoW", pow)
-}
-
-// MarkTrustedPeer marks specific peer trusted, which will allow it to send historic (expired) messages.
-// Note This function is not adding new nodes, the node needs to exists as a peer.
-func (sc *Client) MarkTrustedPeer(ctx context.Context, enode string) error {
-	var ignored bool
-	return sc.c.CallContext(ctx, &ignored, "shh_markTrustedPeer", enode)
-}
-
-// NewKeyPair generates a new public and private key pair for message decryption and encryption.
-// It returns an identifier that can be used to refer to the key.
-func (sc *Client) NewKeyPair(ctx context.Context) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_newKeyPair")
-}
-
-// AddPrivateKey stored the key pair, and returns its ID.
-func (sc *Client) AddPrivateKey(ctx context.Context, key []byte) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_addPrivateKey", hexutil.Bytes(key))
-}
-
-// DeleteKeyPair delete the specifies key.
-func (sc *Client) DeleteKeyPair(ctx context.Context, id string) (string, error) {
-	var ignored bool
-	return id, sc.c.CallContext(ctx, &ignored, "shh_deleteKeyPair", id)
-}
-
-// HasKeyPair returns an indication if the node has a private key or
-// key pair matching the given ID.
-func (sc *Client) HasKeyPair(ctx context.Context, id string) (bool, error) {
-	var has bool
-	return has, sc.c.CallContext(ctx, &has, "shh_hasKeyPair", id)
-}
-
-// PublicKey return the public key for a key ID.
-func (sc *Client) PublicKey(ctx context.Context, id string) ([]byte, error) {
-	var key hexutil.Bytes
-	return []byte(key), sc.c.CallContext(ctx, &key, "shh_getPublicKey", id)
-}
-
-// PrivateKey return the private key for a key ID.
-func (sc *Client) PrivateKey(ctx context.Context, id string) ([]byte, error) {
-	var key hexutil.Bytes
-	return []byte(key), sc.c.CallContext(ctx, &key, "shh_getPrivateKey", id)
-}
-
-// NewSymmetricKey generates a random symmetric key and returns its identifier.
-// Can be used encrypting and decrypting messages where the key is known to both parties.
-func (sc *Client) NewSymmetricKey(ctx context.Context) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_newSymKey")
-}
-
-// AddSymmetricKey stores the key, and returns its identifier.
-func (sc *Client) AddSymmetricKey(ctx context.Context, key []byte) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_addSymKey", hexutil.Bytes(key))
-}
-
-// GenerateSymmetricKeyFromPassword generates the key from password, stores it, and returns its identifier.
-func (sc *Client) GenerateSymmetricKeyFromPassword(ctx context.Context, passwd string) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_generateSymKeyFromPassword", passwd)
-}
-
-// HasSymmetricKey returns an indication if the key associated with the given id is stored in the node.
-func (sc *Client) HasSymmetricKey(ctx context.Context, id string) (bool, error) {
-	var found bool
-	return found, sc.c.CallContext(ctx, &found, "shh_hasSymKey", id)
-}
-
-// GetSymmetricKey returns the symmetric key associated with the given identifier.
-func (sc *Client) GetSymmetricKey(ctx context.Context, id string) ([]byte, error) {
-	var key hexutil.Bytes
-	return []byte(key), sc.c.CallContext(ctx, &key, "shh_getSymKey", id)
-}
-
-// DeleteSymmetricKey deletes the symmetric key associated with the given identifier.
-func (sc *Client) DeleteSymmetricKey(ctx context.Context, id string) error {
-	var ignored bool
-	return sc.c.CallContext(ctx, &ignored, "shh_deleteSymKey", id)
-}
-
-// Post a message onto the network.
-func (sc *Client) Post(ctx context.Context, message whisper.NewMessage) (string, error) {
-	var hash string
-	return hash, sc.c.CallContext(ctx, &hash, "shh_post", message)
-}
-
-// SubscribeMessages subscribes to messages that match the given criteria. This method
-// is only supported on bi-directional connections such as websockets and IPC.
-// NewMessageFilter uses polling and is supported over HTTP.
-func (sc *Client) SubscribeMessages(ctx context.Context, criteria whisper.Criteria, ch chan<- *whisper.Message) (ethereum.Subscription, error) {
-	return sc.c.ShhSubscribe(ctx, ch, "messages", criteria)
-}
-
-// NewMessageFilter creates a filter within the node. This filter can be used to poll
-// for new messages (see FilterMessages) that satisfy the given criteria. A filter can
-// timeout when it was polled for in whisper.filterTimeout.
-func (sc *Client) NewMessageFilter(ctx context.Context, criteria whisper.Criteria) (string, error) {
-	var id string
-	return id, sc.c.CallContext(ctx, &id, "shh_newMessageFilter", criteria)
-}
-
-// DeleteMessageFilter removes the filter associated with the given id.
-func (sc *Client) DeleteMessageFilter(ctx context.Context, id string) error {
-	var ignored bool
-	return sc.c.CallContext(ctx, &ignored, "shh_deleteMessageFilter", id)
-}
-
-// FilterMessages retrieves all messages that are received between the last call to
-// this function and match the criteria that where given when the filter was created.
-func (sc *Client) FilterMessages(ctx context.Context, id string) ([]*whisper.Message, error) {
-	var messages []*whisper.Message
-	return messages, sc.c.CallContext(ctx, &messages, "shh_getFilterMessages", id)
-}

whisper/whisperv6/api.go

@@ -1,593 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-// List of errors
-var (
-	ErrSymAsym              = errors.New("specify either a symmetric or an asymmetric key")
-	ErrInvalidSymmetricKey  = errors.New("invalid symmetric key")
-	ErrInvalidPublicKey     = errors.New("invalid public key")
-	ErrInvalidSigningPubKey = errors.New("invalid signing public key")
-	ErrTooLowPoW            = errors.New("message rejected, PoW too low")
-	ErrNoTopics             = errors.New("missing topic(s)")
-)
-
-// PublicWhisperAPI provides the whisper RPC service that can be
-// use publicly without security implications.
-type PublicWhisperAPI struct {
-	w *Whisper
-
-	mu       sync.Mutex
-	lastUsed map[string]time.Time // keeps track when a filter was polled for the last time.
-}
-
-// NewPublicWhisperAPI create a new RPC whisper service.
-func NewPublicWhisperAPI(w *Whisper) *PublicWhisperAPI {
-	api := &PublicWhisperAPI{
-		w:        w,
-		lastUsed: make(map[string]time.Time),
-	}
-	return api
-}
-
-// Version returns the Whisper sub-protocol version.
-func (api *PublicWhisperAPI) Version(ctx context.Context) string {
-	return ProtocolVersionStr
-}
-
-// Info contains diagnostic information.
-type Info struct {
-	Memory         int     `json:"memory"`         // Memory size of the floating messages in bytes.
-	Messages       int     `json:"messages"`       // Number of floating messages.
-	MinPow         float64 `json:"minPow"`         // Minimal accepted PoW
-	MaxMessageSize uint32  `json:"maxMessageSize"` // Maximum accepted message size
-}
-
-// Info returns diagnostic information about the whisper node.
-func (api *PublicWhisperAPI) Info(ctx context.Context) Info {
-	stats := api.w.Stats()
-	return Info{
-		Memory:         stats.memoryUsed,
-		Messages:       len(api.w.messageQueue) + len(api.w.p2pMsgQueue),
-		MinPow:         api.w.MinPow(),
-		MaxMessageSize: api.w.MaxMessageSize(),
-	}
-}
-
-// SetMaxMessageSize sets the maximum message size that is accepted.
-// Upper limit is defined by MaxMessageSize.
-func (api *PublicWhisperAPI) SetMaxMessageSize(ctx context.Context, size uint32) (bool, error) {
-	return true, api.w.SetMaxMessageSize(size)
-}
-
-// SetMinPoW sets the minimum PoW, and notifies the peers.
-func (api *PublicWhisperAPI) SetMinPoW(ctx context.Context, pow float64) (bool, error) {
-	return true, api.w.SetMinimumPoW(pow)
-}
-
-// SetBloomFilter sets the new value of bloom filter, and notifies the peers.
-func (api *PublicWhisperAPI) SetBloomFilter(ctx context.Context, bloom hexutil.Bytes) (bool, error) {
-	return true, api.w.SetBloomFilter(bloom)
-}
-
-// MarkTrustedPeer marks a peer trusted, which will allow it to send historic (expired) messages.
-// Note: This function is not adding new nodes, the node needs to exists as a peer.
-func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, url string) (bool, error) {
-	n, err := enode.Parse(enode.ValidSchemes, url)
-	if err != nil {
-		return false, err
-	}
-	return true, api.w.AllowP2PMessagesFromPeer(n.ID().Bytes())
-}
-
-// NewKeyPair generates a new public and private key pair for message decryption and encryption.
-// It returns an ID that can be used to refer to the keypair.
-func (api *PublicWhisperAPI) NewKeyPair(ctx context.Context) (string, error) {
-	return api.w.NewKeyPair()
-}
-
-// AddPrivateKey imports the given private key.
-func (api *PublicWhisperAPI) AddPrivateKey(ctx context.Context, privateKey hexutil.Bytes) (string, error) {
-	key, err := crypto.ToECDSA(privateKey)
-	if err != nil {
-		return "", err
-	}
-	return api.w.AddKeyPair(key)
-}
-
-// DeleteKeyPair removes the key with the given key if it exists.
-func (api *PublicWhisperAPI) DeleteKeyPair(ctx context.Context, key string) (bool, error) {
-	if ok := api.w.DeleteKeyPair(key); ok {
-		return true, nil
-	}
-	return false, fmt.Errorf("key pair %s not found", key)
-}
-
-// HasKeyPair returns an indication if the node has a key pair that is associated with the given id.
-func (api *PublicWhisperAPI) HasKeyPair(ctx context.Context, id string) bool {
-	return api.w.HasKeyPair(id)
-}
-
-// GetPublicKey returns the public key associated with the given key. The key is the hex
-// encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62.
-func (api *PublicWhisperAPI) GetPublicKey(ctx context.Context, id string) (hexutil.Bytes, error) {
-	key, err := api.w.GetPrivateKey(id)
-	if err != nil {
-		return hexutil.Bytes{}, err
-	}
-	return crypto.FromECDSAPub(&key.PublicKey), nil
-}
-
-// GetPrivateKey returns the private key associated with the given key. The key is the hex
-// encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62.
-func (api *PublicWhisperAPI) GetPrivateKey(ctx context.Context, id string) (hexutil.Bytes, error) {
-	key, err := api.w.GetPrivateKey(id)
-	if err != nil {
-		return hexutil.Bytes{}, err
-	}
-	return crypto.FromECDSA(key), nil
-}
-
-// NewSymKey generate a random symmetric key.
-// It returns an ID that can be used to refer to the key.
-// Can be used encrypting and decrypting messages where the key is known to both parties.
-func (api *PublicWhisperAPI) NewSymKey(ctx context.Context) (string, error) {
-	return api.w.GenerateSymKey()
-}
-
-// AddSymKey import a symmetric key.
-// It returns an ID that can be used to refer to the key.
-// Can be used encrypting and decrypting messages where the key is known to both parties.
-func (api *PublicWhisperAPI) AddSymKey(ctx context.Context, key hexutil.Bytes) (string, error) {
-	return api.w.AddSymKeyDirect([]byte(key))
-}
-
-// GenerateSymKeyFromPassword derive a key from the given password, stores it, and returns its ID.
-func (api *PublicWhisperAPI) GenerateSymKeyFromPassword(ctx context.Context, passwd string) (string, error) {
-	return api.w.AddSymKeyFromPassword(passwd)
-}
-
-// HasSymKey returns an indication if the node has a symmetric key associated with the given key.
-func (api *PublicWhisperAPI) HasSymKey(ctx context.Context, id string) bool {
-	return api.w.HasSymKey(id)
-}
-
-// GetSymKey returns the symmetric key associated with the given id.
-func (api *PublicWhisperAPI) GetSymKey(ctx context.Context, id string) (hexutil.Bytes, error) {
-	return api.w.GetSymKey(id)
-}
-
-// DeleteSymKey deletes the symmetric key that is associated with the given id.
-func (api *PublicWhisperAPI) DeleteSymKey(ctx context.Context, id string) bool {
-	return api.w.DeleteSymKey(id)
-}
-
-// MakeLightClient turns the node into light client, which does not forward
-// any incoming messages, and sends only messages originated in this node.
-func (api *PublicWhisperAPI) MakeLightClient(ctx context.Context) bool {
-	api.w.SetLightClientMode(true)
-	return api.w.LightClientMode()
-}
-
-// CancelLightClient cancels light client mode.
-func (api *PublicWhisperAPI) CancelLightClient(ctx context.Context) bool {
-	api.w.SetLightClientMode(false)
-	return !api.w.LightClientMode()
-}
-
-//go:generate gencodec -type NewMessage -field-override newMessageOverride -out gen_newmessage_json.go
-
-// NewMessage represents a new whisper message that is posted through the RPC.
-type NewMessage struct {
-	SymKeyID   string    `json:"symKeyID"`
-	PublicKey  []byte    `json:"pubKey"`
-	Sig        string    `json:"sig"`
-	TTL        uint32    `json:"ttl"`
-	Topic      TopicType `json:"topic"`
-	Payload    []byte    `json:"payload"`
-	Padding    []byte    `json:"padding"`
-	PowTime    uint32    `json:"powTime"`
-	PowTarget  float64   `json:"powTarget"`
-	TargetPeer string    `json:"targetPeer"`
-}
-
-type newMessageOverride struct {
-	PublicKey hexutil.Bytes
-	Payload   hexutil.Bytes
-	Padding   hexutil.Bytes
-}
-
-// Post posts a message on the Whisper network.
-// returns the hash of the message in case of success.
-func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (hexutil.Bytes, error) {
-	var (
-		symKeyGiven = len(req.SymKeyID) > 0
-		pubKeyGiven = len(req.PublicKey) > 0
-		err         error
-	)
-
-	// user must specify either a symmetric or an asymmetric key
-	if (symKeyGiven && pubKeyGiven) || (!symKeyGiven && !pubKeyGiven) {
-		return nil, ErrSymAsym
-	}
-
-	params := &MessageParams{
-		TTL:      req.TTL,
-		Payload:  req.Payload,
-		Padding:  req.Padding,
-		WorkTime: req.PowTime,
-		PoW:      req.PowTarget,
-		Topic:    req.Topic,
-	}
-
-	// Set key that is used to sign the message
-	if len(req.Sig) > 0 {
-		if params.Src, err = api.w.GetPrivateKey(req.Sig); err != nil {
-			return nil, err
-		}
-	}
-
-	// Set symmetric key that is used to encrypt the message
-	if symKeyGiven {
-		if params.Topic == (TopicType{}) { // topics are mandatory with symmetric encryption
-			return nil, ErrNoTopics
-		}
-		if params.KeySym, err = api.w.GetSymKey(req.SymKeyID); err != nil {
-			return nil, err
-		}
-		if !validateDataIntegrity(params.KeySym, aesKeyLength) {
-			return nil, ErrInvalidSymmetricKey
-		}
-	}
-
-	// Set asymmetric key that is used to encrypt the message
-	if pubKeyGiven {
-		if params.Dst, err = crypto.UnmarshalPubkey(req.PublicKey); err != nil {
-			return nil, ErrInvalidPublicKey
-		}
-	}
-
-	// encrypt and sent message
-	whisperMsg, err := NewSentMessage(params)
-	if err != nil {
-		return nil, err
-	}
-
-	var result []byte
-	env, err := whisperMsg.Wrap(params)
-	if err != nil {
-		return nil, err
-	}
-
-	// send to specific node (skip PoW check)
-	if len(req.TargetPeer) > 0 {
-		n, err := enode.Parse(enode.ValidSchemes, req.TargetPeer)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse target peer: %s", err)
-		}
-		err = api.w.SendP2PMessage(n.ID().Bytes(), env)
-		if err == nil {
-			hash := env.Hash()
-			result = hash[:]
-		}
-		return result, err
-	}
-
-	// ensure that the message PoW meets the node's minimum accepted PoW
-	if req.PowTarget < api.w.MinPow() {
-		return nil, ErrTooLowPoW
-	}
-
-	err = api.w.Send(env)
-	if err == nil {
-		hash := env.Hash()
-		result = hash[:]
-	}
-	return result, err
-}
-
-//go:generate gencodec -type Criteria -field-override criteriaOverride -out gen_criteria_json.go
-
-// Criteria holds various filter options for inbound messages.
-type Criteria struct {
-	SymKeyID     string      `json:"symKeyID"`
-	PrivateKeyID string      `json:"privateKeyID"`
-	Sig          []byte      `json:"sig"`
-	MinPow       float64     `json:"minPow"`
-	Topics       []TopicType `json:"topics"`
-	AllowP2P     bool        `json:"allowP2P"`
-}
-
-type criteriaOverride struct {
-	Sig hexutil.Bytes
-}
-
-// Messages set up a subscription that fires events when messages arrive that match
-// the given set of criteria.
-func (api *PublicWhisperAPI) Messages(ctx context.Context, crit Criteria) (*rpc.Subscription, error) {
-	var (
-		symKeyGiven = len(crit.SymKeyID) > 0
-		pubKeyGiven = len(crit.PrivateKeyID) > 0
-		err         error
-	)
-
-	// ensure that the RPC connection supports subscriptions
-	notifier, supported := rpc.NotifierFromContext(ctx)
-	if !supported {
-		return nil, rpc.ErrNotificationsUnsupported
-	}
-
-	// user must specify either a symmetric or an asymmetric key
-	if (symKeyGiven && pubKeyGiven) || (!symKeyGiven && !pubKeyGiven) {
-		return nil, ErrSymAsym
-	}
-
-	filter := Filter{
-		PoW:      crit.MinPow,
-		Messages: make(map[common.Hash]*ReceivedMessage),
-		AllowP2P: crit.AllowP2P,
-	}
-
-	if len(crit.Sig) > 0 {
-		if filter.Src, err = crypto.UnmarshalPubkey(crit.Sig); err != nil {
-			return nil, ErrInvalidSigningPubKey
-		}
-	}
-
-	for i, bt := range crit.Topics {
-		if len(bt) == 0 || len(bt) > 4 {
-			return nil, fmt.Errorf("subscribe: topic %d has wrong size: %d", i, len(bt))
-		}
-		filter.Topics = append(filter.Topics, bt[:])
-	}
-
-	// listen for message that are encrypted with the given symmetric key
-	if symKeyGiven {
-		if len(filter.Topics) == 0 {
-			return nil, ErrNoTopics
-		}
-		key, err := api.w.GetSymKey(crit.SymKeyID)
-		if err != nil {
-			return nil, err
-		}
-		if !validateDataIntegrity(key, aesKeyLength) {
-			return nil, ErrInvalidSymmetricKey
-		}
-		filter.KeySym = key
-		filter.SymKeyHash = crypto.Keccak256Hash(filter.KeySym)
-	}
-
-	// listen for messages that are encrypted with the given public key
-	if pubKeyGiven {
-		filter.KeyAsym, err = api.w.GetPrivateKey(crit.PrivateKeyID)
-		if err != nil || filter.KeyAsym == nil {
-			return nil, ErrInvalidPublicKey
-		}
-	}
-
-	id, err := api.w.Subscribe(&filter)
-	if err != nil {
-		return nil, err
-	}
-
-	// create subscription and start waiting for message events
-	rpcSub := notifier.CreateSubscription()
-	go func() {
-		// for now poll internally, refactor whisper internal for channel support
-		ticker := time.NewTicker(250 * time.Millisecond)
-		defer ticker.Stop()
-
-		for {
-			select {
-			case <-ticker.C:
-				if filter := api.w.GetFilter(id); filter != nil {
-					for _, rpcMessage := range toMessage(filter.Retrieve()) {
-						if err := notifier.Notify(rpcSub.ID, rpcMessage); err != nil {
-							log.Error("Failed to send notification", "err", err)
-						}
-					}
-				}
-			case <-rpcSub.Err():
-				api.w.Unsubscribe(id)
-				return
-			case <-notifier.Closed():
-				api.w.Unsubscribe(id)
-				return
-			}
-		}
-	}()
-
-	return rpcSub, nil
-}
-
-//go:generate gencodec -type Message -field-override messageOverride -out gen_message_json.go
-
-// Message is the RPC representation of a whisper message.
-type Message struct {
-	Sig       []byte    `json:"sig,omitempty"`
-	TTL       uint32    `json:"ttl"`
-	Timestamp uint32    `json:"timestamp"`
-	Topic     TopicType `json:"topic"`
-	Payload   []byte    `json:"payload"`
-	Padding   []byte    `json:"padding"`
-	PoW       float64   `json:"pow"`
-	Hash      []byte    `json:"hash"`
-	Dst       []byte    `json:"recipientPublicKey,omitempty"`
-}
-
-type messageOverride struct {
-	Sig     hexutil.Bytes
-	Payload hexutil.Bytes
-	Padding hexutil.Bytes
-	Hash    hexutil.Bytes
-	Dst     hexutil.Bytes
-}
-
-// ToWhisperMessage converts an internal message into an API version.
-func ToWhisperMessage(message *ReceivedMessage) *Message {
-	msg := Message{
-		Payload:   message.Payload,
-		Padding:   message.Padding,
-		Timestamp: message.Sent,
-		TTL:       message.TTL,
-		PoW:       message.PoW,
-		Hash:      message.EnvelopeHash.Bytes(),
-		Topic:     message.Topic,
-	}
-
-	if message.Dst != nil {
-		b := crypto.FromECDSAPub(message.Dst)
-		if b != nil {
-			msg.Dst = b
-		}
-	}
-
-	if isMessageSigned(message.Raw[0]) {
-		b := crypto.FromECDSAPub(message.SigToPubKey())
-		if b != nil {
-			msg.Sig = b
-		}
-	}
-
-	return &msg
-}
-
-// toMessage converts a set of messages to its RPC representation.
-func toMessage(messages []*ReceivedMessage) []*Message {
-	msgs := make([]*Message, len(messages))
-	for i, msg := range messages {
-		msgs[i] = ToWhisperMessage(msg)
-	}
-	return msgs
-}
-
-// GetFilterMessages returns the messages that match the filter criteria and
-// are received between the last poll and now.
-func (api *PublicWhisperAPI) GetFilterMessages(id string) ([]*Message, error) {
-	api.mu.Lock()
-	f := api.w.GetFilter(id)
-	if f == nil {
-		api.mu.Unlock()
-		return nil, fmt.Errorf("filter not found")
-	}
-	api.lastUsed[id] = time.Now()
-	api.mu.Unlock()
-
-	receivedMessages := f.Retrieve()
-	messages := make([]*Message, 0, len(receivedMessages))
-	for _, msg := range receivedMessages {
-		messages = append(messages, ToWhisperMessage(msg))
-	}
-
-	return messages, nil
-}
-
-// DeleteMessageFilter deletes a filter.
-func (api *PublicWhisperAPI) DeleteMessageFilter(id string) (bool, error) {
-	api.mu.Lock()
-	defer api.mu.Unlock()
-
-	delete(api.lastUsed, id)
-	return true, api.w.Unsubscribe(id)
-}
-
-// NewMessageFilter creates a new filter that can be used to poll for
-// (new) messages that satisfy the given criteria.
-func (api *PublicWhisperAPI) NewMessageFilter(req Criteria) (string, error) {
-	var (
-		src     *ecdsa.PublicKey
-		keySym  []byte
-		keyAsym *ecdsa.PrivateKey
-		topics  [][]byte
-
-		symKeyGiven  = len(req.SymKeyID) > 0
-		asymKeyGiven = len(req.PrivateKeyID) > 0
-
-		err error
-	)
-
-	// user must specify either a symmetric or an asymmetric key
-	if (symKeyGiven && asymKeyGiven) || (!symKeyGiven && !asymKeyGiven) {
-		return "", ErrSymAsym
-	}
-
-	if len(req.Sig) > 0 {
-		if src, err = crypto.UnmarshalPubkey(req.Sig); err != nil {
-			return "", ErrInvalidSigningPubKey
-		}
-	}
-
-	if symKeyGiven {
-		if keySym, err = api.w.GetSymKey(req.SymKeyID); err != nil {
-			return "", err
-		}
-		if !validateDataIntegrity(keySym, aesKeyLength) {
-			return "", ErrInvalidSymmetricKey
-		}
-	}
-
-	if asymKeyGiven {
-		if keyAsym, err = api.w.GetPrivateKey(req.PrivateKeyID); err != nil {
-			return "", err
-		}
-	}
-
-	if len(req.Topics) > 0 {
-		topics = make([][]byte, len(req.Topics))
-		for i, topic := range req.Topics {
-			topics[i] = make([]byte, TopicLength)
-			copy(topics[i], topic[:])
-		}
-	}
-
-	f := &Filter{
-		Src:      src,
-		KeySym:   keySym,
-		KeyAsym:  keyAsym,
-		PoW:      req.MinPow,
-		AllowP2P: req.AllowP2P,
-		Topics:   topics,
-		Messages: make(map[common.Hash]*ReceivedMessage),
-	}
-
-	id, err := api.w.Subscribe(f)
-	if err != nil {
-		return "", err
-	}
-
-	api.mu.Lock()
-	api.lastUsed[id] = time.Now()
-	api.mu.Unlock()
-
-	return id, nil
-}

whisper/whisperv6/api_test.go

@@ -1,64 +0,0 @@
-// 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/>.
-
-package whisperv6
-
-import (
-	"bytes"
-	"testing"
-	"time"
-)
-
-func TestMultipleTopicCopyInNewMessageFilter(t *testing.T) {
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	keyID, err := w.GenerateSymKey()
-	if err != nil {
-		t.Fatalf("Error generating symmetric key: %v", err)
-	}
-	api := PublicWhisperAPI{
-		w:        w,
-		lastUsed: make(map[string]time.Time),
-	}
-
-	t1 := [4]byte{0xde, 0xea, 0xbe, 0xef}
-	t2 := [4]byte{0xca, 0xfe, 0xde, 0xca}
-
-	crit := Criteria{
-		SymKeyID: keyID,
-		Topics:   []TopicType{TopicType(t1), TopicType(t2)},
-	}
-
-	_, err = api.NewMessageFilter(crit)
-	if err != nil {
-		t.Fatalf("Error creating the filter: %v", err)
-	}
-
-	found := false
-	candidates := w.filters.getWatchersByTopic(TopicType(t1))
-	for _, f := range candidates {
-		if len(f.Topics) == 2 {
-			if bytes.Equal(f.Topics[0], t1[:]) && bytes.Equal(f.Topics[1], t2[:]) {
-				found = true
-			}
-		}
-	}
-
-	if !found {
-		t.Fatalf("Could not find filter with both topics")
-	}
-}

whisper/whisperv6/benchmarks_test.go

@@ -1,208 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"crypto/sha256"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/crypto"
-	"golang.org/x/crypto/pbkdf2"
-)
-
-func BenchmarkDeriveKeyMaterial(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		pbkdf2.Key([]byte("test"), nil, 65356, aesKeyLength, sha256.New)
-	}
-}
-
-func BenchmarkEncryptionSym(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		msg, _ := NewSentMessage(params)
-		_, err := msg.Wrap(params)
-		if err != nil {
-			b.Errorf("failed Wrap with seed %d: %s.", seed, err)
-			b.Errorf("i = %d, len(msg.Raw) = %d, params.Payload = %d.", i, len(msg.Raw), len(params.Payload))
-			return
-		}
-	}
-}
-
-func BenchmarkEncryptionAsym(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	params.KeySym = nil
-	params.Dst = &key.PublicKey
-
-	for i := 0; i < b.N; i++ {
-		msg, _ := NewSentMessage(params)
-		_, err := msg.Wrap(params)
-		if err != nil {
-			b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-		}
-	}
-}
-
-func BenchmarkDecryptionSymValid(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, _ := NewSentMessage(params)
-	env, err := msg.Wrap(params)
-	if err != nil {
-		b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	f := Filter{KeySym: params.KeySym}
-
-	for i := 0; i < b.N; i++ {
-		msg := env.Open(&f)
-		if msg == nil {
-			b.Fatalf("failed to open with seed %d.", seed)
-		}
-	}
-}
-
-func BenchmarkDecryptionSymInvalid(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, _ := NewSentMessage(params)
-	env, err := msg.Wrap(params)
-	if err != nil {
-		b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	f := Filter{KeySym: []byte("arbitrary stuff here")}
-
-	for i := 0; i < b.N; i++ {
-		msg := env.Open(&f)
-		if msg != nil {
-			b.Fatalf("opened envelope with invalid key, seed: %d.", seed)
-		}
-	}
-}
-
-func BenchmarkDecryptionAsymValid(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	f := Filter{KeyAsym: key}
-	params.KeySym = nil
-	params.Dst = &key.PublicKey
-	msg, _ := NewSentMessage(params)
-	env, err := msg.Wrap(params)
-	if err != nil {
-		b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		msg := env.Open(&f)
-		if msg == nil {
-			b.Fatalf("fail to open, seed: %d.", seed)
-		}
-	}
-}
-
-func BenchmarkDecryptionAsymInvalid(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	params.KeySym = nil
-	params.Dst = &key.PublicKey
-	msg, _ := NewSentMessage(params)
-	env, err := msg.Wrap(params)
-	if err != nil {
-		b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	key, err = crypto.GenerateKey()
-	if err != nil {
-		b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	f := Filter{KeyAsym: key}
-
-	for i := 0; i < b.N; i++ {
-		msg := env.Open(&f)
-		if msg != nil {
-			b.Fatalf("opened envelope with invalid key, seed: %d.", seed)
-		}
-	}
-}
-
-func increment(x []byte) {
-	for i := 0; i < len(x); i++ {
-		x[i]++
-		if x[i] != 0 {
-			break
-		}
-	}
-}
-
-func BenchmarkPoW(b *testing.B) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	params.Payload = make([]byte, 32)
-	params.PoW = 10.0
-	params.TTL = 1
-
-	for i := 0; i < b.N; i++ {
-		increment(params.Payload)
-		msg, _ := NewSentMessage(params)
-		_, err := msg.Wrap(params)
-		if err != nil {
-			b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-		}
-	}
-}

whisper/whisperv6/config.go

@@ -1,31 +0,0 @@
-// Copyright 2017 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/>.
-
-package whisperv6
-
-// Config represents the configuration state of a whisper node.
-type Config struct {
-	MaxMessageSize                        uint32  `toml:",omitempty"`
-	MinimumAcceptedPOW                    float64 `toml:",omitempty"`
-	RestrictConnectionBetweenLightClients bool    `toml:",omitempty"`
-}
-
-// DefaultConfig represents (shocker!) the default configuration.
-var DefaultConfig = Config{
-	MaxMessageSize:                        DefaultMaxMessageSize,
-	MinimumAcceptedPOW:                    DefaultMinimumPoW,
-	RestrictConnectionBetweenLightClients: true,
-}

whisper/whisperv6/doc.go

@@ -1,92 +0,0 @@
-// Copyright 2016 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/>.
-
-/*
-Package whisper implements the Whisper protocol (version 6).
-
-Whisper combines aspects of both DHTs and datagram messaging systems (e.g. UDP).
-As such it may be likened and compared to both, not dissimilar to the
-matter/energy duality (apologies to physicists for the blatant abuse of a
-fundamental and beautiful natural principle).
-
-Whisper is a pure identity-based messaging system. Whisper provides a low-level
-(non-application-specific) but easily-accessible API without being based upon
-or prejudiced by the low-level hardware attributes and characteristics,
-particularly the notion of singular endpoints.
-*/
-
-// Contains the Whisper protocol constant definitions
-
-package whisperv6
-
-import (
-	"time"
-
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// Whisper protocol parameters
-const (
-	ProtocolVersion    = uint64(6) // Protocol version number
-	ProtocolVersionStr = "6.0"     // The same, as a string
-	ProtocolName       = "shh"     // Nickname of the protocol in geth
-
-	// whisper protocol message codes, according to EIP-627
-	statusCode           = 0   // used by whisper protocol
-	messagesCode         = 1   // normal whisper message
-	powRequirementCode   = 2   // PoW requirement
-	bloomFilterExCode    = 3   // bloom filter exchange
-	p2pRequestCode       = 126 // peer-to-peer message, used by Dapp protocol
-	p2pMessageCode       = 127 // peer-to-peer message (to be consumed by the peer, but not forwarded any further)
-	NumberOfMessageCodes = 128
-
-	SizeMask      = byte(3) // mask used to extract the size of payload size field from the flags
-	signatureFlag = byte(4)
-
-	TopicLength     = 4                      // in bytes
-	signatureLength = crypto.SignatureLength // in bytes
-	aesKeyLength    = 32                     // in bytes
-	aesNonceLength  = 12                     // in bytes; for more info please see cipher.gcmStandardNonceSize & aesgcm.NonceSize()
-	keyIDSize       = 32                     // in bytes
-	BloomFilterSize = 64                     // in bytes
-	flagsLength     = 1
-
-	EnvelopeHeaderLength = 20
-
-	MaxMessageSize        = uint32(10 * 1024 * 1024) // maximum accepted size of a message.
-	DefaultMaxMessageSize = uint32(1024 * 1024)
-	DefaultMinimumPoW     = 0.2
-
-	padSizeLimit      = 256 // just an arbitrary number, could be changed without breaking the protocol
-	messageQueueLimit = 1024
-
-	expirationCycle   = time.Second
-	transmissionCycle = 300 * time.Millisecond
-
-	DefaultTTL           = 50 // seconds
-	DefaultSyncAllowance = 10 // seconds
-)
-
-// MailServer represents a mail server, capable of
-// archiving the old messages for subsequent delivery
-// to the peers. Any implementation must ensure that both
-// functions are thread-safe. Also, they must return ASAP.
-// DeliverMail should use directMessagesCode for delivery,
-// in order to bypass the expiry checks.
-type MailServer interface {
-	Archive(env *Envelope)
-	DeliverMail(whisperPeer *Peer, request *Envelope)
-}

whisper/whisperv6/envelope.go

@@ -1,280 +0,0 @@
-// Copyright 2016 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/>.
-
-// Contains the Whisper protocol Envelope element.
-
-package whisperv6
-
-import (
-	"crypto/ecdsa"
-	"encoding/binary"
-	"fmt"
-	gmath "math"
-	"math/big"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/crypto/ecies"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// Envelope represents a clear-text data packet to transmit through the Whisper
-// network. Its contents may or may not be encrypted and signed.
-type Envelope struct {
-	Expiry uint32
-	TTL    uint32
-	Topic  TopicType
-	Data   []byte
-	Nonce  uint64
-
-	pow float64 // Message-specific PoW as described in the Whisper specification.
-
-	// the following variables should not be accessed directly, use the corresponding function instead: Hash(), Bloom()
-	hash  common.Hash // Cached hash of the envelope to avoid rehashing every time.
-	bloom []byte
-}
-
-// size returns the size of envelope as it is sent (i.e. public fields only)
-func (e *Envelope) size() int {
-	return EnvelopeHeaderLength + len(e.Data)
-}
-
-// rlpWithoutNonce returns the RLP encoded envelope contents, except the nonce.
-func (e *Envelope) rlpWithoutNonce() []byte {
-	res, _ := rlp.EncodeToBytes([]interface{}{e.Expiry, e.TTL, e.Topic, e.Data})
-	return res
-}
-
-// NewEnvelope wraps a Whisper message with expiration and destination data
-// included into an envelope for network forwarding.
-func NewEnvelope(ttl uint32, topic TopicType, msg *sentMessage) *Envelope {
-	env := Envelope{
-		Expiry: uint32(time.Now().Add(time.Second * time.Duration(ttl)).Unix()),
-		TTL:    ttl,
-		Topic:  topic,
-		Data:   msg.Raw,
-		Nonce:  0,
-	}
-
-	return &env
-}
-
-// Seal closes the envelope by spending the requested amount of time as a proof
-// of work on hashing the data.
-func (e *Envelope) Seal(options *MessageParams) error {
-	if options.PoW == 0 {
-		// PoW is not required
-		return nil
-	}
-
-	var target, bestLeadingZeros int
-	if options.PoW < 0 {
-		// target is not set - the function should run for a period
-		// of time specified in WorkTime param. Since we can predict
-		// the execution time, we can also adjust Expiry.
-		e.Expiry += options.WorkTime
-	} else {
-		target = e.powToFirstBit(options.PoW)
-	}
-
-	rlp := e.rlpWithoutNonce()
-	buf := make([]byte, len(rlp)+8)
-	copy(buf, rlp)
-	asAnInt := new(big.Int)
-
-	finish := time.Now().Add(time.Duration(options.WorkTime) * time.Second).UnixNano()
-	for nonce := uint64(0); time.Now().UnixNano() < finish; {
-		for i := 0; i < 1024; i++ {
-			binary.BigEndian.PutUint64(buf[len(rlp):], nonce)
-			h := crypto.Keccak256(buf)
-			asAnInt.SetBytes(h)
-			leadingZeros := 256 - asAnInt.BitLen()
-			if leadingZeros > bestLeadingZeros {
-				e.Nonce, bestLeadingZeros = nonce, leadingZeros
-				if target > 0 && bestLeadingZeros >= target {
-					return nil
-				}
-			}
-			nonce++
-		}
-	}
-
-	if target > 0 && bestLeadingZeros < target {
-		return fmt.Errorf("failed to reach the PoW target, specified pow time (%d seconds) was insufficient", options.WorkTime)
-	}
-
-	return nil
-}
-
-// PoW computes (if necessary) and returns the proof of work target
-// of the envelope.
-func (e *Envelope) PoW() float64 {
-	if e.pow == 0 {
-		e.calculatePoW(0)
-	}
-	return e.pow
-}
-
-func (e *Envelope) calculatePoW(diff uint32) {
-	rlp := e.rlpWithoutNonce()
-	buf := make([]byte, len(rlp)+8)
-	copy(buf, rlp)
-	binary.BigEndian.PutUint64(buf[len(rlp):], e.Nonce)
-	powHash := new(big.Int).SetBytes(crypto.Keccak256(buf))
-	leadingZeroes := 256 - powHash.BitLen()
-	x := gmath.Pow(2, float64(leadingZeroes))
-	x /= float64(len(rlp))
-	x /= float64(e.TTL + diff)
-	e.pow = x
-}
-
-func (e *Envelope) powToFirstBit(pow float64) int {
-	x := pow
-	x *= float64(e.size())
-	x *= float64(e.TTL)
-	bits := gmath.Log2(x)
-	bits = gmath.Ceil(bits)
-	res := int(bits)
-	if res < 1 {
-		res = 1
-	}
-	return res
-}
-
-// Hash returns the SHA3 hash of the envelope, calculating it if not yet done.
-func (e *Envelope) Hash() common.Hash {
-	if (e.hash == common.Hash{}) {
-		encoded, _ := rlp.EncodeToBytes(e)
-		e.hash = crypto.Keccak256Hash(encoded)
-	}
-	return e.hash
-}
-
-// DecodeRLP decodes an Envelope from an RLP data stream.
-func (e *Envelope) DecodeRLP(s *rlp.Stream) error {
-	raw, err := s.Raw()
-	if err != nil {
-		return err
-	}
-	// The decoding of Envelope uses the struct fields but also needs
-	// to compute the hash of the whole RLP-encoded envelope. This
-	// type has the same structure as Envelope but is not an
-	// rlp.Decoder (does not implement DecodeRLP function).
-	// Only public members will be encoded.
-	type rlpenv Envelope
-	if err := rlp.DecodeBytes(raw, (*rlpenv)(e)); err != nil {
-		return err
-	}
-	e.hash = crypto.Keccak256Hash(raw)
-	return nil
-}
-
-// OpenAsymmetric tries to decrypt an envelope, potentially encrypted with a particular key.
-func (e *Envelope) OpenAsymmetric(key *ecdsa.PrivateKey) (*ReceivedMessage, error) {
-	message := &ReceivedMessage{Raw: e.Data}
-	err := message.decryptAsymmetric(key)
-	switch err {
-	case nil:
-		return message, nil
-	case ecies.ErrInvalidPublicKey: // addressed to somebody else
-		return nil, err
-	default:
-		return nil, fmt.Errorf("unable to open envelope, decrypt failed: %v", err)
-	}
-}
-
-// OpenSymmetric tries to decrypt an envelope, potentially encrypted with a particular key.
-func (e *Envelope) OpenSymmetric(key []byte) (msg *ReceivedMessage, err error) {
-	msg = &ReceivedMessage{Raw: e.Data}
-	err = msg.decryptSymmetric(key)
-	if err != nil {
-		msg = nil
-	}
-	return msg, err
-}
-
-// Open tries to decrypt an envelope, and populates the message fields in case of success.
-func (e *Envelope) Open(watcher *Filter) (msg *ReceivedMessage) {
-	if watcher == nil {
-		return nil
-	}
-
-	// The API interface forbids filters doing both symmetric and asymmetric encryption.
-	if watcher.expectsAsymmetricEncryption() && watcher.expectsSymmetricEncryption() {
-		return nil
-	}
-
-	if watcher.expectsAsymmetricEncryption() {
-		msg, _ = e.OpenAsymmetric(watcher.KeyAsym)
-		if msg != nil {
-			msg.Dst = &watcher.KeyAsym.PublicKey
-		}
-	} else if watcher.expectsSymmetricEncryption() {
-		msg, _ = e.OpenSymmetric(watcher.KeySym)
-		if msg != nil {
-			msg.SymKeyHash = crypto.Keccak256Hash(watcher.KeySym)
-		}
-	}
-
-	if msg != nil {
-		ok := msg.ValidateAndParse()
-		if !ok {
-			return nil
-		}
-		msg.Topic = e.Topic
-		msg.PoW = e.PoW()
-		msg.TTL = e.TTL
-		msg.Sent = e.Expiry - e.TTL
-		msg.EnvelopeHash = e.Hash()
-	}
-	return msg
-}
-
-// Bloom maps 4-bytes Topic into 64-byte bloom filter with 3 bits set (at most).
-func (e *Envelope) Bloom() []byte {
-	if e.bloom == nil {
-		e.bloom = TopicToBloom(e.Topic)
-	}
-	return e.bloom
-}
-
-// TopicToBloom converts the topic (4 bytes) to the bloom filter (64 bytes)
-func TopicToBloom(topic TopicType) []byte {
-	b := make([]byte, BloomFilterSize)
-	var index [3]int
-	for j := 0; j < 3; j++ {
-		index[j] = int(topic[j])
-		if (topic[3] & (1 << uint(j))) != 0 {
-			index[j] += 256
-		}
-	}
-
-	for j := 0; j < 3; j++ {
-		byteIndex := index[j] / 8
-		bitIndex := index[j] % 8
-		b[byteIndex] = (1 << uint(bitIndex))
-	}
-	return b
-}
-
-// GetEnvelope retrieves an envelope from the message queue by its hash.
-// It returns nil if the envelope can not be found.
-func (w *Whisper) GetEnvelope(hash common.Hash) *Envelope {
-	w.poolMu.RLock()
-	defer w.poolMu.RUnlock()
-	return w.envelopes[hash]
-}

whisper/whisperv6/envelope_test.go

@@ -1,91 +0,0 @@
-// Copyright 2017 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/>.
-
-// Contains the tests associated with the Whisper protocol Envelope object.
-
-package whisperv6
-
-import (
-	mrand "math/rand"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-func TestPoWCalculationsWithNoLeadingZeros(t *testing.T) {
-	e := Envelope{
-		TTL:   1,
-		Data:  []byte{0xde, 0xad, 0xbe, 0xef},
-		Nonce: 100000,
-	}
-
-	e.calculatePoW(0)
-
-	if e.pow != 0.07692307692307693 {
-		t.Fatalf("invalid PoW calculation. Expected 0.07692307692307693, got %v", e.pow)
-	}
-}
-
-func TestPoWCalculationsWith8LeadingZeros(t *testing.T) {
-	e := Envelope{
-		TTL:   1,
-		Data:  []byte{0xde, 0xad, 0xbe, 0xef},
-		Nonce: 276,
-	}
-	e.calculatePoW(0)
-
-	if e.pow != 19.692307692307693 {
-		t.Fatalf("invalid PoW calculation. Expected 19.692307692307693, got %v", e.pow)
-	}
-}
-
-func TestEnvelopeOpenAcceptsOnlyOneKeyTypeInFilter(t *testing.T) {
-	symKey := make([]byte, aesKeyLength)
-	mrand.Read(symKey)
-
-	asymKey, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-
-	params := MessageParams{
-		PoW:      0.01,
-		WorkTime: 1,
-		TTL:      uint32(mrand.Intn(1024)),
-		Payload:  make([]byte, 50),
-		KeySym:   symKey,
-		Dst:      nil,
-	}
-
-	mrand.Read(params.Payload)
-
-	msg, err := NewSentMessage(&params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-
-	e, err := msg.Wrap(&params)
-	if err != nil {
-		t.Fatalf("Failed to Wrap the message in an envelope with seed %d: %s", seed, err)
-	}
-
-	f := Filter{KeySym: symKey, KeyAsym: asymKey}
-
-	decrypted := e.Open(&f)
-	if decrypted != nil {
-		t.Fatalf("Managed to decrypt a message with an invalid filter, seed %d", seed)
-	}
-}

whisper/whisperv6/filter.go

@@ -1,262 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"crypto/ecdsa"
-	"fmt"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// Filter represents a Whisper message filter
-type Filter struct {
-	Src        *ecdsa.PublicKey  // Sender of the message
-	KeyAsym    *ecdsa.PrivateKey // Private Key of recipient
-	KeySym     []byte            // Key associated with the Topic
-	Topics     [][]byte          // Topics to filter messages with
-	PoW        float64           // Proof of work as described in the Whisper spec
-	AllowP2P   bool              // Indicates whether this filter is interested in direct peer-to-peer messages
-	SymKeyHash common.Hash       // The Keccak256Hash of the symmetric key, needed for optimization
-	id         string            // unique identifier
-
-	Messages map[common.Hash]*ReceivedMessage
-	mutex    sync.RWMutex
-}
-
-// Filters represents a collection of filters
-type Filters struct {
-	watchers map[string]*Filter
-
-	topicMatcher     map[TopicType]map[*Filter]struct{} // map a topic to the filters that are interested in being notified when a message matches that topic
-	allTopicsMatcher map[*Filter]struct{}               // list all the filters that will be notified of a new message, no matter what its topic is
-
-	whisper *Whisper
-	mutex   sync.RWMutex
-}
-
-// NewFilters returns a newly created filter collection
-func NewFilters(w *Whisper) *Filters {
-	return &Filters{
-		watchers:         make(map[string]*Filter),
-		topicMatcher:     make(map[TopicType]map[*Filter]struct{}),
-		allTopicsMatcher: make(map[*Filter]struct{}),
-		whisper:          w,
-	}
-}
-
-// Install will add a new filter to the filter collection
-func (fs *Filters) Install(watcher *Filter) (string, error) {
-	if watcher.KeySym != nil && watcher.KeyAsym != nil {
-		return "", fmt.Errorf("filters must choose between symmetric and asymmetric keys")
-	}
-
-	if watcher.Messages == nil {
-		watcher.Messages = make(map[common.Hash]*ReceivedMessage)
-	}
-
-	id, err := GenerateRandomID()
-	if err != nil {
-		return "", err
-	}
-
-	fs.mutex.Lock()
-	defer fs.mutex.Unlock()
-
-	if fs.watchers[id] != nil {
-		return "", fmt.Errorf("failed to generate unique ID")
-	}
-
-	if watcher.expectsSymmetricEncryption() {
-		watcher.SymKeyHash = crypto.Keccak256Hash(watcher.KeySym)
-	}
-
-	watcher.id = id
-	fs.watchers[id] = watcher
-	fs.addTopicMatcher(watcher)
-	return id, err
-}
-
-// Uninstall will remove a filter whose id has been specified from
-// the filter collection
-func (fs *Filters) Uninstall(id string) bool {
-	fs.mutex.Lock()
-	defer fs.mutex.Unlock()
-	if fs.watchers[id] != nil {
-		fs.removeFromTopicMatchers(fs.watchers[id])
-		delete(fs.watchers, id)
-		return true
-	}
-	return false
-}
-
-// addTopicMatcher adds a filter to the topic matchers.
-// If the filter's Topics array is empty, it will be tried on every topic.
-// Otherwise, it will be tried on the topics specified.
-func (fs *Filters) addTopicMatcher(watcher *Filter) {
-	if len(watcher.Topics) == 0 {
-		fs.allTopicsMatcher[watcher] = struct{}{}
-	} else {
-		for _, t := range watcher.Topics {
-			topic := BytesToTopic(t)
-			if fs.topicMatcher[topic] == nil {
-				fs.topicMatcher[topic] = make(map[*Filter]struct{})
-			}
-			fs.topicMatcher[topic][watcher] = struct{}{}
-		}
-	}
-}
-
-// removeFromTopicMatchers removes a filter from the topic matchers
-func (fs *Filters) removeFromTopicMatchers(watcher *Filter) {
-	delete(fs.allTopicsMatcher, watcher)
-	for _, topic := range watcher.Topics {
-		delete(fs.topicMatcher[BytesToTopic(topic)], watcher)
-	}
-}
-
-// getWatchersByTopic returns a slice containing the filters that
-// match a specific topic
-func (fs *Filters) getWatchersByTopic(topic TopicType) []*Filter {
-	res := make([]*Filter, 0, len(fs.allTopicsMatcher))
-	for watcher := range fs.allTopicsMatcher {
-		res = append(res, watcher)
-	}
-	for watcher := range fs.topicMatcher[topic] {
-		res = append(res, watcher)
-	}
-	return res
-}
-
-// Get returns a filter from the collection with a specific ID
-func (fs *Filters) Get(id string) *Filter {
-	fs.mutex.RLock()
-	defer fs.mutex.RUnlock()
-	return fs.watchers[id]
-}
-
-// NotifyWatchers notifies any filter that has declared interest
-// for the envelope's topic.
-func (fs *Filters) NotifyWatchers(env *Envelope, p2pMessage bool) {
-	var msg *ReceivedMessage
-
-	fs.mutex.RLock()
-	defer fs.mutex.RUnlock()
-
-	candidates := fs.getWatchersByTopic(env.Topic)
-	for _, watcher := range candidates {
-		if p2pMessage && !watcher.AllowP2P {
-			log.Trace(fmt.Sprintf("msg [%x], filter [%s]: p2p messages are not allowed", env.Hash(), watcher.id))
-			continue
-		}
-
-		var match bool
-		if msg != nil {
-			match = watcher.MatchMessage(msg)
-		} else {
-			match = watcher.MatchEnvelope(env)
-			if match {
-				msg = env.Open(watcher)
-				if msg == nil {
-					log.Trace("processing message: failed to open", "message", env.Hash().Hex(), "filter", watcher.id)
-				}
-			} else {
-				log.Trace("processing message: does not match", "message", env.Hash().Hex(), "filter", watcher.id)
-			}
-		}
-
-		if match && msg != nil {
-			log.Trace("processing message: decrypted", "hash", env.Hash().Hex())
-			if watcher.Src == nil || IsPubKeyEqual(msg.Src, watcher.Src) {
-				watcher.Trigger(msg)
-			}
-		}
-	}
-}
-
-func (f *Filter) expectsAsymmetricEncryption() bool {
-	return f.KeyAsym != nil
-}
-
-func (f *Filter) expectsSymmetricEncryption() bool {
-	return f.KeySym != nil
-}
-
-// Trigger adds a yet-unknown message to the filter's list of
-// received messages.
-func (f *Filter) Trigger(msg *ReceivedMessage) {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	if _, exist := f.Messages[msg.EnvelopeHash]; !exist {
-		f.Messages[msg.EnvelopeHash] = msg
-	}
-}
-
-// Retrieve will return the list of all received messages associated
-// to a filter.
-func (f *Filter) Retrieve() (all []*ReceivedMessage) {
-	f.mutex.Lock()
-	defer f.mutex.Unlock()
-
-	all = make([]*ReceivedMessage, 0, len(f.Messages))
-	for _, msg := range f.Messages {
-		all = append(all, msg)
-	}
-
-	f.Messages = make(map[common.Hash]*ReceivedMessage) // delete old messages
-	return all
-}
-
-// MatchMessage checks if the filter matches an already decrypted
-// message (i.e. a Message that has already been handled by
-// MatchEnvelope when checked by a previous filter).
-// Topics are not checked here, since this is done by topic matchers.
-func (f *Filter) MatchMessage(msg *ReceivedMessage) bool {
-	if f.PoW > 0 && msg.PoW < f.PoW {
-		return false
-	}
-
-	if f.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() {
-		return IsPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst)
-	} else if f.expectsSymmetricEncryption() && msg.isSymmetricEncryption() {
-		return f.SymKeyHash == msg.SymKeyHash
-	}
-	return false
-}
-
-// MatchEnvelope checks if it's worth decrypting the message. If
-// it returns `true`, client code is expected to attempt decrypting
-// the message and subsequently call MatchMessage.
-// Topics are not checked here, since this is done by topic matchers.
-func (f *Filter) MatchEnvelope(envelope *Envelope) bool {
-	return f.PoW <= 0 || envelope.pow >= f.PoW
-}
-
-// IsPubKeyEqual checks that two public keys are equal
-func IsPubKeyEqual(a, b *ecdsa.PublicKey) bool {
-	if !ValidatePublicKey(a) {
-		return false
-	} else if !ValidatePublicKey(b) {
-		return false
-	}
-	// the curve is always the same, just compare the points
-	return a.X.Cmp(b.X) == 0 && a.Y.Cmp(b.Y) == 0
-}

whisper/whisperv6/filter_test.go

@@ -1,836 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"math/big"
-	mrand "math/rand"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-var seed int64
-
-// InitSingleTest should be called in the beginning of every
-// test, which uses RNG, in order to make the tests
-// reproduciblity independent of their sequence.
-func InitSingleTest() {
-	seed = time.Now().Unix()
-	mrand.Seed(seed)
-}
-
-type FilterTestCase struct {
-	f      *Filter
-	id     string
-	alive  bool
-	msgCnt int
-}
-
-func generateFilter(t *testing.T, symmetric bool) (*Filter, error) {
-	var f Filter
-	f.Messages = make(map[common.Hash]*ReceivedMessage)
-
-	const topicNum = 8
-	f.Topics = make([][]byte, topicNum)
-	for i := 0; i < topicNum; i++ {
-		f.Topics[i] = make([]byte, 4)
-		mrand.Read(f.Topics[i])
-		f.Topics[i][0] = 0x01
-	}
-
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("generateFilter 1 failed with seed %d.", seed)
-		return nil, err
-	}
-	f.Src = &key.PublicKey
-
-	if symmetric {
-		f.KeySym = make([]byte, aesKeyLength)
-		mrand.Read(f.KeySym)
-		f.SymKeyHash = crypto.Keccak256Hash(f.KeySym)
-	} else {
-		f.KeyAsym, err = crypto.GenerateKey()
-		if err != nil {
-			t.Fatalf("generateFilter 2 failed with seed %d.", seed)
-			return nil, err
-		}
-	}
-
-	// AcceptP2P & PoW are not set
-	return &f, nil
-}
-
-func generateTestCases(t *testing.T, SizeTestFilters int) []FilterTestCase {
-	cases := make([]FilterTestCase, SizeTestFilters)
-	for i := 0; i < SizeTestFilters; i++ {
-		f, _ := generateFilter(t, true)
-		cases[i].f = f
-		cases[i].alive = mrand.Int()&int(1) == 0
-	}
-	return cases
-}
-
-func TestInstallFilters(t *testing.T) {
-	InitSingleTest()
-
-	const SizeTestFilters = 256
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	filters := NewFilters(w)
-	tst := generateTestCases(t, SizeTestFilters)
-
-	var err error
-	var j string
-	for i := 0; i < SizeTestFilters; i++ {
-		j, err = filters.Install(tst[i].f)
-		if err != nil {
-			t.Fatalf("seed %d: failed to install filter: %s", seed, err)
-		}
-		tst[i].id = j
-		if len(j) != keyIDSize*2 {
-			t.Fatalf("seed %d: wrong filter id size [%d]", seed, len(j))
-		}
-	}
-
-	for _, testCase := range tst {
-		if !testCase.alive {
-			filters.Uninstall(testCase.id)
-		}
-	}
-
-	for i, testCase := range tst {
-		fil := filters.Get(testCase.id)
-		exist := fil != nil
-		if exist != testCase.alive {
-			t.Fatalf("seed %d: failed alive: %d, %v, %v", seed, i, exist, testCase.alive)
-		}
-		if exist && fil.PoW != testCase.f.PoW {
-			t.Fatalf("seed %d: failed Get: %d, %v, %v", seed, i, exist, testCase.alive)
-		}
-	}
-}
-
-func TestInstallSymKeyGeneratesHash(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	filters := NewFilters(w)
-	filter, _ := generateFilter(t, true)
-
-	// save the current SymKeyHash for comparison
-	initialSymKeyHash := filter.SymKeyHash
-
-	// ensure the SymKeyHash is invalid, for Install to recreate it
-	var invalid common.Hash
-	filter.SymKeyHash = invalid
-
-	_, err := filters.Install(filter)
-
-	if err != nil {
-		t.Fatalf("Error installing the filter: %s", err)
-	}
-
-	for i, b := range filter.SymKeyHash {
-		if b != initialSymKeyHash[i] {
-			t.Fatalf("The filter's symmetric key hash was not properly generated by Install")
-		}
-	}
-}
-
-func TestInstallIdenticalFilters(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	filters := NewFilters(w)
-	filter1, _ := generateFilter(t, true)
-
-	// Copy the first filter since some of its fields
-	// are randomly gnerated.
-	filter2 := &Filter{
-		KeySym:   filter1.KeySym,
-		Topics:   filter1.Topics,
-		PoW:      filter1.PoW,
-		AllowP2P: filter1.AllowP2P,
-		Messages: make(map[common.Hash]*ReceivedMessage),
-	}
-
-	_, err := filters.Install(filter1)
-
-	if err != nil {
-		t.Fatalf("Error installing the first filter with seed %d: %s", seed, err)
-	}
-
-	_, err = filters.Install(filter2)
-
-	if err != nil {
-		t.Fatalf("Error installing the second filter with seed %d: %s", seed, err)
-	}
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("Error generating message parameters with seed %d: %s", seed, err)
-	}
-
-	params.KeySym = filter1.KeySym
-	params.Topic = BytesToTopic(filter1.Topics[0])
-
-	filter1.Src = &params.Src.PublicKey
-	filter2.Src = &params.Src.PublicKey
-
-	sentMessage, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := sentMessage.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	msg := env.Open(filter1)
-	if msg == nil {
-		t.Fatalf("failed to Open with filter1")
-	}
-
-	if !filter1.MatchEnvelope(env) {
-		t.Fatalf("failed matching with the first filter")
-	}
-
-	if !filter2.MatchEnvelope(env) {
-		t.Fatalf("failed matching with the first filter")
-	}
-
-	if !filter1.MatchMessage(msg) {
-		t.Fatalf("failed matching with the second filter")
-	}
-
-	if !filter2.MatchMessage(msg) {
-		t.Fatalf("failed matching with the second filter")
-	}
-}
-
-func TestInstallFilterWithSymAndAsymKeys(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	filters := NewFilters(w)
-	filter1, _ := generateFilter(t, true)
-
-	asymKey, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("Unable to create asymetric keys: %v", err)
-	}
-
-	// Copy the first filter since some of its fields
-	// are randomly gnerated.
-	filter := &Filter{
-		KeySym:   filter1.KeySym,
-		KeyAsym:  asymKey,
-		Topics:   filter1.Topics,
-		PoW:      filter1.PoW,
-		AllowP2P: filter1.AllowP2P,
-		Messages: make(map[common.Hash]*ReceivedMessage),
-	}
-
-	_, err = filters.Install(filter)
-
-	if err == nil {
-		t.Fatalf("Error detecting that a filter had both an asymmetric and symmetric key, with seed %d", seed)
-	}
-}
-
-func TestComparePubKey(t *testing.T) {
-	InitSingleTest()
-
-	key1, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed to generate first key with seed %d: %s.", seed, err)
-	}
-	key2, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed to generate second key with seed %d: %s.", seed, err)
-	}
-	if IsPubKeyEqual(&key1.PublicKey, &key2.PublicKey) {
-		t.Fatalf("public keys are equal, seed %d.", seed)
-	}
-
-	// generate key3 == key1
-	mrand.Seed(seed)
-	key3, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed to generate third key with seed %d: %s.", seed, err)
-	}
-	if IsPubKeyEqual(&key1.PublicKey, &key3.PublicKey) {
-		t.Fatalf("key1 == key3, seed %d.", seed)
-	}
-}
-
-func TestMatchEnvelope(t *testing.T) {
-	InitSingleTest()
-
-	fsym, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
-	}
-
-	fasym, err := generateFilter(t, false)
-	if err != nil {
-		t.Fatalf("failed generateFilter() with seed %d: %s.", seed, err)
-	}
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	params.Topic[0] = 0xFF // topic mismatch
-
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	if _, err = msg.Wrap(params); err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	// encrypt symmetrically
-	i := mrand.Int() % 4
-	fsym.Topics[i] = params.Topic[:]
-	fasym.Topics[i] = params.Topic[:]
-	msg, err = NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap() with seed %d: %s.", seed, err)
-	}
-
-	// symmetric + matching topic: match
-	match := fsym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope() symmetric with seed %d.", seed)
-	}
-
-	// symmetric + matching topic + insufficient PoW: mismatch
-	fsym.PoW = env.PoW() + 1.0
-	match = fsym.MatchEnvelope(env)
-	if match {
-		t.Fatalf("failed MatchEnvelope(symmetric + matching topic + insufficient PoW) asymmetric with seed %d.", seed)
-	}
-
-	// symmetric + matching topic + sufficient PoW: match
-	fsym.PoW = env.PoW() / 2
-	match = fsym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(symmetric + matching topic + sufficient PoW) with seed %d.", seed)
-	}
-
-	// symmetric + topics are nil (wildcard): match
-	prevTopics := fsym.Topics
-	fsym.Topics = nil
-	match = fsym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(symmetric + topics are nil) with seed %d.", seed)
-	}
-	fsym.Topics = prevTopics
-
-	// encrypt asymmetrically
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	params.KeySym = nil
-	params.Dst = &key.PublicKey
-	msg, err = NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err = msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap() with seed %d: %s.", seed, err)
-	}
-
-	// encryption method mismatch
-	match = fsym.MatchEnvelope(env)
-	if match {
-		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
-	}
-
-	// asymmetric + mismatching topic: mismatch
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(asymmetric + mismatching topic) with seed %d.", seed)
-	}
-
-	// asymmetric + matching topic: match
-	fasym.Topics[i] = fasym.Topics[i+1]
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(asymmetric + matching topic) with seed %d.", seed)
-	}
-
-	// asymmetric + filter without topic (wildcard): match
-	fasym.Topics = nil
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(asymmetric + filter without topic) with seed %d.", seed)
-	}
-
-	// asymmetric + insufficient PoW: mismatch
-	fasym.PoW = env.PoW() + 1.0
-	match = fasym.MatchEnvelope(env)
-	if match {
-		t.Fatalf("failed MatchEnvelope(asymmetric + insufficient PoW) with seed %d.", seed)
-	}
-
-	// asymmetric + sufficient PoW: match
-	fasym.PoW = env.PoW() / 2
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(asymmetric + sufficient PoW) with seed %d.", seed)
-	}
-
-	// filter without topic + envelope without topic: match
-	env.Topic = TopicType{}
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		t.Fatalf("failed MatchEnvelope(filter without topic + envelope without topic) with seed %d.", seed)
-	}
-
-	// filter with topic + envelope without topic: mismatch
-	fasym.Topics = fsym.Topics
-	match = fasym.MatchEnvelope(env)
-	if !match {
-		// topic mismatch should have no affect, as topics are handled by topic matchers
-		t.Fatalf("failed MatchEnvelope(filter without topic + envelope without topic) with seed %d.", seed)
-	}
-}
-
-func TestMatchMessageSym(t *testing.T) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	f, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
-	}
-
-	const index = 1
-	params.KeySym = f.KeySym
-	params.Topic = BytesToTopic(f.Topics[index])
-
-	sentMessage, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := sentMessage.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	msg := env.Open(f)
-	if msg == nil {
-		t.Fatalf("failed Open with seed %d.", seed)
-	}
-
-	// Src: match
-	*f.Src.X = *params.Src.PublicKey.X
-	*f.Src.Y = *params.Src.PublicKey.Y
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(src match) with seed %d.", seed)
-	}
-
-	// insufficient PoW: mismatch
-	f.PoW = msg.PoW + 1.0
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(insufficient PoW) with seed %d.", seed)
-	}
-
-	// sufficient PoW: match
-	f.PoW = msg.PoW / 2
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(sufficient PoW) with seed %d.", seed)
-	}
-
-	// topic mismatch
-	f.Topics[index][0]++
-	if !f.MatchMessage(msg) {
-		// topic mismatch should have no affect, as topics are handled by topic matchers
-		t.Fatalf("failed MatchEnvelope(topic mismatch) with seed %d.", seed)
-	}
-	f.Topics[index][0]--
-
-	// key mismatch
-	f.SymKeyHash[0]++
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(key mismatch) with seed %d.", seed)
-	}
-	f.SymKeyHash[0]--
-
-	// Src absent: match
-	f.Src = nil
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(src absent) with seed %d.", seed)
-	}
-
-	// key hash mismatch
-	h := f.SymKeyHash
-	f.SymKeyHash = common.Hash{}
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(key hash mismatch) with seed %d.", seed)
-	}
-	f.SymKeyHash = h
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(key hash match) with seed %d.", seed)
-	}
-
-	// encryption method mismatch
-	f.KeySym = nil
-	f.KeyAsym, err = crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
-	}
-}
-
-func TestMatchMessageAsym(t *testing.T) {
-	InitSingleTest()
-
-	f, err := generateFilter(t, false)
-	if err != nil {
-		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
-	}
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	const index = 1
-	params.Topic = BytesToTopic(f.Topics[index])
-	params.Dst = &f.KeyAsym.PublicKey
-	keySymOrig := params.KeySym
-	params.KeySym = nil
-
-	sentMessage, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := sentMessage.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	msg := env.Open(f)
-	if msg == nil {
-		t.Fatalf("failed to open with seed %d.", seed)
-	}
-
-	// Src: match
-	*f.Src.X = *params.Src.PublicKey.X
-	*f.Src.Y = *params.Src.PublicKey.Y
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchMessage(src match) with seed %d.", seed)
-	}
-
-	// insufficient PoW: mismatch
-	f.PoW = msg.PoW + 1.0
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(insufficient PoW) with seed %d.", seed)
-	}
-
-	// sufficient PoW: match
-	f.PoW = msg.PoW / 2
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(sufficient PoW) with seed %d.", seed)
-	}
-
-	// topic mismatch
-	f.Topics[index][0]++
-	if !f.MatchMessage(msg) {
-		// topic mismatch should have no affect, as topics are handled by topic matchers
-		t.Fatalf("failed MatchEnvelope(topic mismatch) with seed %d.", seed)
-	}
-	f.Topics[index][0]--
-
-	// key mismatch
-	prev := *f.KeyAsym.PublicKey.X
-	zero := *big.NewInt(0)
-	*f.KeyAsym.PublicKey.X = zero
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(key mismatch) with seed %d.", seed)
-	}
-	*f.KeyAsym.PublicKey.X = prev
-
-	// Src absent: match
-	f.Src = nil
-	if !f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(src absent) with seed %d.", seed)
-	}
-
-	// encryption method mismatch
-	f.KeySym = keySymOrig
-	f.KeyAsym = nil
-	if f.MatchMessage(msg) {
-		t.Fatalf("failed MatchEnvelope(encryption method mismatch) with seed %d.", seed)
-	}
-}
-
-func cloneFilter(orig *Filter) *Filter {
-	var clone Filter
-	clone.Messages = make(map[common.Hash]*ReceivedMessage)
-	clone.Src = orig.Src
-	clone.KeyAsym = orig.KeyAsym
-	clone.KeySym = orig.KeySym
-	clone.Topics = orig.Topics
-	clone.PoW = orig.PoW
-	clone.AllowP2P = orig.AllowP2P
-	clone.SymKeyHash = orig.SymKeyHash
-	return &clone
-}
-
-func generateCompatibeEnvelope(t *testing.T, f *Filter) *Envelope {
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-		return nil
-	}
-
-	params.KeySym = f.KeySym
-	params.Topic = BytesToTopic(f.Topics[2])
-	sentMessage, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := sentMessage.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-		return nil
-	}
-	return env
-}
-
-func TestWatchers(t *testing.T) {
-	InitSingleTest()
-
-	const NumFilters = 16
-	const NumMessages = 256
-	var i int
-	var j uint32
-	var e *Envelope
-	var x, firstID string
-	var err error
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	filters := NewFilters(w)
-	tst := generateTestCases(t, NumFilters)
-	for i = 0; i < NumFilters; i++ {
-		tst[i].f.Src = nil
-		x, err = filters.Install(tst[i].f)
-		if err != nil {
-			t.Fatalf("failed to install filter with seed %d: %s.", seed, err)
-		}
-		tst[i].id = x
-		if len(firstID) == 0 {
-			firstID = x
-		}
-	}
-
-	lastID := x
-
-	var envelopes [NumMessages]*Envelope
-	for i = 0; i < NumMessages; i++ {
-		j = mrand.Uint32() % NumFilters
-		e = generateCompatibeEnvelope(t, tst[j].f)
-		envelopes[i] = e
-		tst[j].msgCnt++
-	}
-
-	for i = 0; i < NumMessages; i++ {
-		filters.NotifyWatchers(envelopes[i], false)
-	}
-
-	var total int
-	var mail []*ReceivedMessage
-	var count [NumFilters]int
-
-	for i = 0; i < NumFilters; i++ {
-		mail = tst[i].f.Retrieve()
-		count[i] = len(mail)
-		total += len(mail)
-	}
-
-	if total != NumMessages {
-		t.Fatalf("failed with seed %d: total = %d, want: %d.", seed, total, NumMessages)
-	}
-
-	for i = 0; i < NumFilters; i++ {
-		mail = tst[i].f.Retrieve()
-		if len(mail) != 0 {
-			t.Fatalf("failed with seed %d: i = %d.", seed, i)
-		}
-
-		if tst[i].msgCnt != count[i] {
-			t.Fatalf("failed with seed %d: count[%d]: get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
-		}
-	}
-
-	// another round with a cloned filter
-
-	clone := cloneFilter(tst[0].f)
-	filters.Uninstall(lastID)
-	total = 0
-	last := NumFilters - 1
-	tst[last].f = clone
-	filters.Install(clone)
-	for i = 0; i < NumFilters; i++ {
-		tst[i].msgCnt = 0
-		count[i] = 0
-	}
-
-	// make sure that the first watcher receives at least one message
-	e = generateCompatibeEnvelope(t, tst[0].f)
-	envelopes[0] = e
-	tst[0].msgCnt++
-	for i = 1; i < NumMessages; i++ {
-		j = mrand.Uint32() % NumFilters
-		e = generateCompatibeEnvelope(t, tst[j].f)
-		envelopes[i] = e
-		tst[j].msgCnt++
-	}
-
-	for i = 0; i < NumMessages; i++ {
-		filters.NotifyWatchers(envelopes[i], false)
-	}
-
-	for i = 0; i < NumFilters; i++ {
-		mail = tst[i].f.Retrieve()
-		count[i] = len(mail)
-		total += len(mail)
-	}
-
-	combined := tst[0].msgCnt + tst[last].msgCnt
-	if total != NumMessages+count[0] {
-		t.Fatalf("failed with seed %d: total = %d, count[0] = %d.", seed, total, count[0])
-	}
-
-	if combined != count[0] {
-		t.Fatalf("failed with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0])
-	}
-
-	if combined != count[last] {
-		t.Fatalf("failed with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last])
-	}
-
-	for i = 1; i < NumFilters-1; i++ {
-		mail = tst[i].f.Retrieve()
-		if len(mail) != 0 {
-			t.Fatalf("failed with seed %d: i = %d.", seed, i)
-		}
-
-		if tst[i].msgCnt != count[i] {
-			t.Fatalf("failed with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
-		}
-	}
-
-	// test AcceptP2P
-
-	total = 0
-	filters.NotifyWatchers(envelopes[0], true)
-
-	for i = 0; i < NumFilters; i++ {
-		mail = tst[i].f.Retrieve()
-		total += len(mail)
-	}
-
-	if total != 0 {
-		t.Fatalf("failed with seed %d: total: got %d, want 0.", seed, total)
-	}
-
-	f := filters.Get(firstID)
-	if f == nil {
-		t.Fatalf("failed to get the filter with seed %d.", seed)
-	}
-	f.AllowP2P = true
-	total = 0
-	filters.NotifyWatchers(envelopes[0], true)
-
-	for i = 0; i < NumFilters; i++ {
-		mail = tst[i].f.Retrieve()
-		total += len(mail)
-	}
-
-	if total != 1 {
-		t.Fatalf("failed with seed %d: total: got %d, want 1.", seed, total)
-	}
-}
-
-func TestVariableTopics(t *testing.T) {
-	InitSingleTest()
-
-	const lastTopicByte = 3
-	var match bool
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	f, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
-	}
-
-	for i := 0; i < 4; i++ {
-		env.Topic = BytesToTopic(f.Topics[i])
-		match = f.MatchEnvelope(env)
-		if !match {
-			t.Fatalf("failed MatchEnvelope symmetric with seed %d, step %d.", seed, i)
-		}
-
-		f.Topics[i][lastTopicByte]++
-		match = f.MatchEnvelope(env)
-		if !match {
-			// topic mismatch should have no affect, as topics are handled by topic matchers
-			t.Fatalf("MatchEnvelope symmetric with seed %d, step %d.", seed, i)
-		}
-	}
-}

whisper/whisperv6/gen_criteria_json.go

@@ -1,66 +0,0 @@
-// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
-
-package whisperv6
-
-import (
-	"encoding/json"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-var _ = (*criteriaOverride)(nil)
-
-// MarshalJSON marshals type Criteria to a json string
-func (c Criteria) MarshalJSON() ([]byte, error) {
-	type Criteria struct {
-		SymKeyID     string        `json:"symKeyID"`
-		PrivateKeyID string        `json:"privateKeyID"`
-		Sig          hexutil.Bytes `json:"sig"`
-		MinPow       float64       `json:"minPow"`
-		Topics       []TopicType   `json:"topics"`
-		AllowP2P     bool          `json:"allowP2P"`
-	}
-	var enc Criteria
-	enc.SymKeyID = c.SymKeyID
-	enc.PrivateKeyID = c.PrivateKeyID
-	enc.Sig = c.Sig
-	enc.MinPow = c.MinPow
-	enc.Topics = c.Topics
-	enc.AllowP2P = c.AllowP2P
-	return json.Marshal(&enc)
-}
-
-// UnmarshalJSON unmarshals type Criteria to a json string
-func (c *Criteria) UnmarshalJSON(input []byte) error {
-	type Criteria struct {
-		SymKeyID     *string        `json:"symKeyID"`
-		PrivateKeyID *string        `json:"privateKeyID"`
-		Sig          *hexutil.Bytes `json:"sig"`
-		MinPow       *float64       `json:"minPow"`
-		Topics       []TopicType    `json:"topics"`
-		AllowP2P     *bool          `json:"allowP2P"`
-	}
-	var dec Criteria
-	if err := json.Unmarshal(input, &dec); err != nil {
-		return err
-	}
-	if dec.SymKeyID != nil {
-		c.SymKeyID = *dec.SymKeyID
-	}
-	if dec.PrivateKeyID != nil {
-		c.PrivateKeyID = *dec.PrivateKeyID
-	}
-	if dec.Sig != nil {
-		c.Sig = *dec.Sig
-	}
-	if dec.MinPow != nil {
-		c.MinPow = *dec.MinPow
-	}
-	if dec.Topics != nil {
-		c.Topics = dec.Topics
-	}
-	if dec.AllowP2P != nil {
-		c.AllowP2P = *dec.AllowP2P
-	}
-	return nil
-}

whisper/whisperv6/gen_message_json.go

@@ -1,84 +0,0 @@
-// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
-
-package whisperv6
-
-import (
-	"encoding/json"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-var _ = (*messageOverride)(nil)
-
-// MarshalJSON marshals type Message to a json string
-func (m Message) MarshalJSON() ([]byte, error) {
-	type Message struct {
-		Sig       hexutil.Bytes `json:"sig,omitempty"`
-		TTL       uint32        `json:"ttl"`
-		Timestamp uint32        `json:"timestamp"`
-		Topic     TopicType     `json:"topic"`
-		Payload   hexutil.Bytes `json:"payload"`
-		Padding   hexutil.Bytes `json:"padding"`
-		PoW       float64       `json:"pow"`
-		Hash      hexutil.Bytes `json:"hash"`
-		Dst       hexutil.Bytes `json:"recipientPublicKey,omitempty"`
-	}
-	var enc Message
-	enc.Sig = m.Sig
-	enc.TTL = m.TTL
-	enc.Timestamp = m.Timestamp
-	enc.Topic = m.Topic
-	enc.Payload = m.Payload
-	enc.Padding = m.Padding
-	enc.PoW = m.PoW
-	enc.Hash = m.Hash
-	enc.Dst = m.Dst
-	return json.Marshal(&enc)
-}
-
-// UnmarshalJSON unmarshals type Message to a json string
-func (m *Message) UnmarshalJSON(input []byte) error {
-	type Message struct {
-		Sig       *hexutil.Bytes `json:"sig,omitempty"`
-		TTL       *uint32        `json:"ttl"`
-		Timestamp *uint32        `json:"timestamp"`
-		Topic     *TopicType     `json:"topic"`
-		Payload   *hexutil.Bytes `json:"payload"`
-		Padding   *hexutil.Bytes `json:"padding"`
-		PoW       *float64       `json:"pow"`
-		Hash      *hexutil.Bytes `json:"hash"`
-		Dst       *hexutil.Bytes `json:"recipientPublicKey,omitempty"`
-	}
-	var dec Message
-	if err := json.Unmarshal(input, &dec); err != nil {
-		return err
-	}
-	if dec.Sig != nil {
-		m.Sig = *dec.Sig
-	}
-	if dec.TTL != nil {
-		m.TTL = *dec.TTL
-	}
-	if dec.Timestamp != nil {
-		m.Timestamp = *dec.Timestamp
-	}
-	if dec.Topic != nil {
-		m.Topic = *dec.Topic
-	}
-	if dec.Payload != nil {
-		m.Payload = *dec.Payload
-	}
-	if dec.Padding != nil {
-		m.Padding = *dec.Padding
-	}
-	if dec.PoW != nil {
-		m.PoW = *dec.PoW
-	}
-	if dec.Hash != nil {
-		m.Hash = *dec.Hash
-	}
-	if dec.Dst != nil {
-		m.Dst = *dec.Dst
-	}
-	return nil
-}

whisper/whisperv6/gen_newmessage_json.go

@@ -1,90 +0,0 @@
-// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
-
-package whisperv6
-
-import (
-	"encoding/json"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-var _ = (*newMessageOverride)(nil)
-
-// MarshalJSON marshals type NewMessage to a json string
-func (n NewMessage) MarshalJSON() ([]byte, error) {
-	type NewMessage struct {
-		SymKeyID   string        `json:"symKeyID"`
-		PublicKey  hexutil.Bytes `json:"pubKey"`
-		Sig        string        `json:"sig"`
-		TTL        uint32        `json:"ttl"`
-		Topic      TopicType     `json:"topic"`
-		Payload    hexutil.Bytes `json:"payload"`
-		Padding    hexutil.Bytes `json:"padding"`
-		PowTime    uint32        `json:"powTime"`
-		PowTarget  float64       `json:"powTarget"`
-		TargetPeer string        `json:"targetPeer"`
-	}
-	var enc NewMessage
-	enc.SymKeyID = n.SymKeyID
-	enc.PublicKey = n.PublicKey
-	enc.Sig = n.Sig
-	enc.TTL = n.TTL
-	enc.Topic = n.Topic
-	enc.Payload = n.Payload
-	enc.Padding = n.Padding
-	enc.PowTime = n.PowTime
-	enc.PowTarget = n.PowTarget
-	enc.TargetPeer = n.TargetPeer
-	return json.Marshal(&enc)
-}
-
-// UnmarshalJSON unmarshals type NewMessage to a json string
-func (n *NewMessage) UnmarshalJSON(input []byte) error {
-	type NewMessage struct {
-		SymKeyID   *string        `json:"symKeyID"`
-		PublicKey  *hexutil.Bytes `json:"pubKey"`
-		Sig        *string        `json:"sig"`
-		TTL        *uint32        `json:"ttl"`
-		Topic      *TopicType     `json:"topic"`
-		Payload    *hexutil.Bytes `json:"payload"`
-		Padding    *hexutil.Bytes `json:"padding"`
-		PowTime    *uint32        `json:"powTime"`
-		PowTarget  *float64       `json:"powTarget"`
-		TargetPeer *string        `json:"targetPeer"`
-	}
-	var dec NewMessage
-	if err := json.Unmarshal(input, &dec); err != nil {
-		return err
-	}
-	if dec.SymKeyID != nil {
-		n.SymKeyID = *dec.SymKeyID
-	}
-	if dec.PublicKey != nil {
-		n.PublicKey = *dec.PublicKey
-	}
-	if dec.Sig != nil {
-		n.Sig = *dec.Sig
-	}
-	if dec.TTL != nil {
-		n.TTL = *dec.TTL
-	}
-	if dec.Topic != nil {
-		n.Topic = *dec.Topic
-	}
-	if dec.Payload != nil {
-		n.Payload = *dec.Payload
-	}
-	if dec.Padding != nil {
-		n.Padding = *dec.Padding
-	}
-	if dec.PowTime != nil {
-		n.PowTime = *dec.PowTime
-	}
-	if dec.PowTarget != nil {
-		n.PowTarget = *dec.PowTarget
-	}
-	if dec.TargetPeer != nil {
-		n.TargetPeer = *dec.TargetPeer
-	}
-	return nil
-}

whisper/whisperv6/message.go

@@ -1,355 +0,0 @@
-// Copyright 2016 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/>.
-
-// Contains the Whisper protocol Message element.
-
-package whisperv6
-
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/ecdsa"
-	crand "crypto/rand"
-	"encoding/binary"
-	"errors"
-	mrand "math/rand"
-	"strconv"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/crypto/ecies"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// MessageParams specifies the exact way a message should be wrapped
-// into an Envelope.
-type MessageParams struct {
-	TTL      uint32
-	Src      *ecdsa.PrivateKey
-	Dst      *ecdsa.PublicKey
-	KeySym   []byte
-	Topic    TopicType
-	WorkTime uint32
-	PoW      float64
-	Payload  []byte
-	Padding  []byte
-}
-
-// SentMessage represents an end-user data packet to transmit through the
-// Whisper protocol. These are wrapped into Envelopes that need not be
-// understood by intermediate nodes, just forwarded.
-type sentMessage struct {
-	Raw []byte
-}
-
-// ReceivedMessage represents a data packet to be received through the
-// Whisper protocol and successfully decrypted.
-type ReceivedMessage struct {
-	Raw []byte
-
-	Payload   []byte
-	Padding   []byte
-	Signature []byte
-	Salt      []byte
-
-	PoW   float64          // Proof of work as described in the Whisper spec
-	Sent  uint32           // Time when the message was posted into the network
-	TTL   uint32           // Maximum time to live allowed for the message
-	Src   *ecdsa.PublicKey // Message recipient (identity used to decode the message)
-	Dst   *ecdsa.PublicKey // Message recipient (identity used to decode the message)
-	Topic TopicType
-
-	SymKeyHash   common.Hash // The Keccak256Hash of the key
-	EnvelopeHash common.Hash // Message envelope hash to act as a unique id
-}
-
-func isMessageSigned(flags byte) bool {
-	return (flags & signatureFlag) != 0
-}
-
-func (msg *ReceivedMessage) isSymmetricEncryption() bool {
-	return msg.SymKeyHash != common.Hash{}
-}
-
-func (msg *ReceivedMessage) isAsymmetricEncryption() bool {
-	return msg.Dst != nil
-}
-
-// NewSentMessage creates and initializes a non-signed, non-encrypted Whisper message.
-func NewSentMessage(params *MessageParams) (*sentMessage, error) {
-	const payloadSizeFieldMaxSize = 4
-	msg := sentMessage{}
-	msg.Raw = make([]byte, 1,
-		flagsLength+payloadSizeFieldMaxSize+len(params.Payload)+len(params.Padding)+signatureLength+padSizeLimit)
-	msg.Raw[0] = 0 // set all the flags to zero
-	msg.addPayloadSizeField(params.Payload)
-	msg.Raw = append(msg.Raw, params.Payload...)
-	err := msg.appendPadding(params)
-	return &msg, err
-}
-
-// addPayloadSizeField appends the auxiliary field containing the size of payload
-func (msg *sentMessage) addPayloadSizeField(payload []byte) {
-	fieldSize := getSizeOfPayloadSizeField(payload)
-	field := make([]byte, 4)
-	binary.LittleEndian.PutUint32(field, uint32(len(payload)))
-	field = field[:fieldSize]
-	msg.Raw = append(msg.Raw, field...)
-	msg.Raw[0] |= byte(fieldSize)
-}
-
-// getSizeOfPayloadSizeField returns the number of bytes necessary to encode the size of payload
-func getSizeOfPayloadSizeField(payload []byte) int {
-	s := 1
-	for i := len(payload); i >= 256; i /= 256 {
-		s++
-	}
-	return s
-}
-
-// appendPadding appends the padding specified in params.
-// If no padding is provided in params, then random padding is generated.
-func (msg *sentMessage) appendPadding(params *MessageParams) error {
-	if len(params.Padding) != 0 {
-		// padding data was provided by the Dapp, just use it as is
-		msg.Raw = append(msg.Raw, params.Padding...)
-		return nil
-	}
-
-	rawSize := flagsLength + getSizeOfPayloadSizeField(params.Payload) + len(params.Payload)
-	if params.Src != nil {
-		rawSize += signatureLength
-	}
-	odd := rawSize % padSizeLimit
-	paddingSize := padSizeLimit - odd
-	pad := make([]byte, paddingSize)
-	_, err := crand.Read(pad)
-	if err != nil {
-		return err
-	}
-	if !validateDataIntegrity(pad, paddingSize) {
-		return errors.New("failed to generate random padding of size " + strconv.Itoa(paddingSize))
-	}
-	msg.Raw = append(msg.Raw, pad...)
-	return nil
-}
-
-// sign calculates and sets the cryptographic signature for the message,
-// also setting the sign flag.
-func (msg *sentMessage) sign(key *ecdsa.PrivateKey) error {
-	if isMessageSigned(msg.Raw[0]) {
-		// this should not happen, but no reason to panic
-		log.Error("failed to sign the message: already signed")
-		return nil
-	}
-
-	msg.Raw[0] |= signatureFlag // it is important to set this flag before signing
-	hash := crypto.Keccak256(msg.Raw)
-	signature, err := crypto.Sign(hash, key)
-	if err != nil {
-		msg.Raw[0] &= (0xFF ^ signatureFlag) // clear the flag
-		return err
-	}
-	msg.Raw = append(msg.Raw, signature...)
-	return nil
-}
-
-// encryptAsymmetric encrypts a message with a public key.
-func (msg *sentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error {
-	if !ValidatePublicKey(key) {
-		return errors.New("invalid public key provided for asymmetric encryption")
-	}
-	encrypted, err := ecies.Encrypt(crand.Reader, ecies.ImportECDSAPublic(key), msg.Raw, nil, nil)
-	if err == nil {
-		msg.Raw = encrypted
-	}
-	return err
-}
-
-// encryptSymmetric encrypts a message with a topic key, using AES-GCM-256.
-// nonce size should be 12 bytes (see cipher.gcmStandardNonceSize).
-func (msg *sentMessage) encryptSymmetric(key []byte) (err error) {
-	if !validateDataIntegrity(key, aesKeyLength) {
-		return errors.New("invalid key provided for symmetric encryption, size: " + strconv.Itoa(len(key)))
-	}
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return err
-	}
-	aesgcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return err
-	}
-	salt, err := generateSecureRandomData(aesNonceLength) // never use more than 2^32 random nonces with a given key
-	if err != nil {
-		return err
-	}
-	encrypted := aesgcm.Seal(nil, salt, msg.Raw, nil)
-	msg.Raw = append(encrypted, salt...)
-	return nil
-}
-
-// generateSecureRandomData generates random data where extra security is required.
-// The purpose of this function is to prevent some bugs in software or in hardware
-// from delivering not-very-random data. This is especially useful for AES nonce,
-// where true randomness does not really matter, but it is very important to have
-// a unique nonce for every message.
-func generateSecureRandomData(length int) ([]byte, error) {
-	x := make([]byte, length)
-	y := make([]byte, length)
-	res := make([]byte, length)
-
-	_, err := crand.Read(x)
-	if err != nil {
-		return nil, err
-	} else if !validateDataIntegrity(x, length) {
-		return nil, errors.New("crypto/rand failed to generate secure random data")
-	}
-	_, err = mrand.Read(y)
-	if err != nil {
-		return nil, err
-	} else if !validateDataIntegrity(y, length) {
-		return nil, errors.New("math/rand failed to generate secure random data")
-	}
-	for i := 0; i < length; i++ {
-		res[i] = x[i] ^ y[i]
-	}
-	if !validateDataIntegrity(res, length) {
-		return nil, errors.New("failed to generate secure random data")
-	}
-	return res, nil
-}
-
-// Wrap bundles the message into an Envelope to transmit over the network.
-func (msg *sentMessage) Wrap(options *MessageParams) (envelope *Envelope, err error) {
-	if options.TTL == 0 {
-		options.TTL = DefaultTTL
-	}
-	if options.Src != nil {
-		if err = msg.sign(options.Src); err != nil {
-			return nil, err
-		}
-	}
-	if options.Dst != nil {
-		err = msg.encryptAsymmetric(options.Dst)
-	} else if options.KeySym != nil {
-		err = msg.encryptSymmetric(options.KeySym)
-	} else {
-		err = errors.New("unable to encrypt the message: neither symmetric nor assymmetric key provided")
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	envelope = NewEnvelope(options.TTL, options.Topic, msg)
-	if err = envelope.Seal(options); err != nil {
-		return nil, err
-	}
-	return envelope, nil
-}
-
-// decryptSymmetric decrypts a message with a topic key, using AES-GCM-256.
-// nonce size should be 12 bytes (see cipher.gcmStandardNonceSize).
-func (msg *ReceivedMessage) decryptSymmetric(key []byte) error {
-	// symmetric messages are expected to contain the 12-byte nonce at the end of the payload
-	if len(msg.Raw) < aesNonceLength {
-		return errors.New("missing salt or invalid payload in symmetric message")
-	}
-	salt := msg.Raw[len(msg.Raw)-aesNonceLength:]
-
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return err
-	}
-	aesgcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return err
-	}
-	decrypted, err := aesgcm.Open(nil, salt, msg.Raw[:len(msg.Raw)-aesNonceLength], nil)
-	if err != nil {
-		return err
-	}
-	msg.Raw = decrypted
-	msg.Salt = salt
-	return nil
-}
-
-// decryptAsymmetric decrypts an encrypted payload with a private key.
-func (msg *ReceivedMessage) decryptAsymmetric(key *ecdsa.PrivateKey) error {
-	decrypted, err := ecies.ImportECDSA(key).Decrypt(msg.Raw, nil, nil)
-	if err == nil {
-		msg.Raw = decrypted
-	}
-	return err
-}
-
-// ValidateAndParse checks the message validity and extracts the fields in case of success.
-func (msg *ReceivedMessage) ValidateAndParse() bool {
-	end := len(msg.Raw)
-	if end < 1 {
-		return false
-	}
-
-	if isMessageSigned(msg.Raw[0]) {
-		end -= signatureLength
-		if end <= 1 {
-			return false
-		}
-		msg.Signature = msg.Raw[end : end+signatureLength]
-		msg.Src = msg.SigToPubKey()
-		if msg.Src == nil {
-			return false
-		}
-	}
-
-	beg := 1
-	payloadSize := 0
-	sizeOfPayloadSizeField := int(msg.Raw[0] & SizeMask) // number of bytes indicating the size of payload
-	if sizeOfPayloadSizeField != 0 {
-		payloadSize = int(bytesToUintLittleEndian(msg.Raw[beg : beg+sizeOfPayloadSizeField]))
-		if payloadSize+1 > end {
-			return false
-		}
-		beg += sizeOfPayloadSizeField
-		msg.Payload = msg.Raw[beg : beg+payloadSize]
-	}
-
-	beg += payloadSize
-	msg.Padding = msg.Raw[beg:end]
-	return true
-}
-
-// SigToPubKey returns the public key associated to the message's
-// signature.
-func (msg *ReceivedMessage) SigToPubKey() *ecdsa.PublicKey {
-	defer func() { recover() }() // in case of invalid signature
-
-	pub, err := crypto.SigToPub(msg.hash(), msg.Signature)
-	if err != nil {
-		log.Error("failed to recover public key from signature", "err", err)
-		return nil
-	}
-	return pub
-}
-
-// hash calculates the SHA3 checksum of the message flags, payload size field, payload and padding.
-func (msg *ReceivedMessage) hash() []byte {
-	if isMessageSigned(msg.Raw[0]) {
-		sz := len(msg.Raw) - signatureLength
-		return crypto.Keccak256(msg.Raw[:sz])
-	}
-	return crypto.Keccak256(msg.Raw)
-}

whisper/whisperv6/message_test.go

@@ -1,471 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	mrand "math/rand"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-func generateMessageParams() (*MessageParams, error) {
-	// set all the parameters except p.Dst and p.Padding
-
-	buf := make([]byte, 4)
-	mrand.Read(buf)
-	sz := mrand.Intn(400)
-
-	var p MessageParams
-	p.PoW = 0.001
-	p.WorkTime = 1
-	p.TTL = uint32(mrand.Intn(1024))
-	p.Payload = make([]byte, sz)
-	p.KeySym = make([]byte, aesKeyLength)
-	mrand.Read(p.Payload)
-	mrand.Read(p.KeySym)
-	p.Topic = BytesToTopic(buf)
-
-	var err error
-	p.Src, err = crypto.GenerateKey()
-	if err != nil {
-		return nil, err
-	}
-
-	return &p, nil
-}
-
-func singleMessageTest(t *testing.T, symmetric bool) {
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-
-	if !symmetric {
-		params.KeySym = nil
-		params.Dst = &key.PublicKey
-	}
-
-	text := make([]byte, 0, 512)
-	text = append(text, params.Payload...)
-
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	var decrypted *ReceivedMessage
-	if symmetric {
-		decrypted, err = env.OpenSymmetric(params.KeySym)
-	} else {
-		decrypted, err = env.OpenAsymmetric(key)
-	}
-
-	if err != nil {
-		t.Fatalf("failed to encrypt with seed %d: %s.", seed, err)
-	}
-
-	if !decrypted.ValidateAndParse() {
-		t.Fatalf("failed to validate with seed %d, symmetric = %v.", seed, symmetric)
-	}
-
-	if !bytes.Equal(text, decrypted.Payload) {
-		t.Fatalf("failed with seed %d: compare payload.", seed)
-	}
-	if !isMessageSigned(decrypted.Raw[0]) {
-		t.Fatalf("failed with seed %d: unsigned.", seed)
-	}
-	if len(decrypted.Signature) != signatureLength {
-		t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
-	}
-	if !IsPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
-		t.Fatalf("failed with seed %d: signature mismatch.", seed)
-	}
-}
-
-func TestMessageEncryption(t *testing.T) {
-	InitSingleTest()
-
-	var symmetric bool
-	for i := 0; i < 256; i++ {
-		singleMessageTest(t, symmetric)
-		symmetric = !symmetric
-	}
-}
-
-func TestMessageWrap(t *testing.T) {
-	seed = int64(1777444222)
-	mrand.Seed(seed)
-	target := 128.0
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.TTL = 1
-	params.WorkTime = 12
-	params.PoW = target
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	pow := env.PoW()
-	if pow < target {
-		t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
-	}
-
-	// set PoW target too high, expect error
-	msg2, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.TTL = 1000000
-	params.WorkTime = 1
-	params.PoW = 10000000.0
-	_, err = msg2.Wrap(params)
-	if err == nil {
-		t.Fatalf("unexpectedly reached the PoW target with seed %d.", seed)
-	}
-}
-
-func TestMessageSeal(t *testing.T) {
-	// this test depends on deterministic choice of seed (1976726903)
-	seed = int64(1976726903)
-	mrand.Seed(seed)
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.TTL = 1
-
-	env := NewEnvelope(params.TTL, params.Topic, msg)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	env.Expiry = uint32(seed) // make it deterministic
-	target := 32.0
-	params.WorkTime = 4
-	params.PoW = target
-	env.Seal(params)
-
-	env.calculatePoW(0)
-	pow := env.PoW()
-	if pow < target {
-		t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
-	}
-
-	params.WorkTime = 1
-	params.PoW = 1000000000.0
-	env.Seal(params)
-	env.calculatePoW(0)
-	pow = env.PoW()
-	if pow < 2*target {
-		t.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow)
-	}
-}
-
-func TestEnvelopeOpen(t *testing.T) {
-	InitSingleTest()
-
-	var symmetric bool
-	for i := 0; i < 32; i++ {
-		singleEnvelopeOpenTest(t, symmetric)
-		symmetric = !symmetric
-	}
-}
-
-func singleEnvelopeOpenTest(t *testing.T, symmetric bool) {
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
-	}
-
-	if !symmetric {
-		params.KeySym = nil
-		params.Dst = &key.PublicKey
-	}
-
-	text := make([]byte, 0, 512)
-	text = append(text, params.Payload...)
-
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	var f Filter
-	if symmetric {
-		f = Filter{KeySym: params.KeySym}
-	} else {
-		f = Filter{KeyAsym: key}
-	}
-	decrypted := env.Open(&f)
-	if decrypted == nil {
-		t.Fatalf("failed to open with seed %d.", seed)
-	}
-
-	if !bytes.Equal(text, decrypted.Payload) {
-		t.Fatalf("failed with seed %d: compare payload.", seed)
-	}
-	if !isMessageSigned(decrypted.Raw[0]) {
-		t.Fatalf("failed with seed %d: unsigned.", seed)
-	}
-	if len(decrypted.Signature) != signatureLength {
-		t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
-	}
-	if !IsPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
-		t.Fatalf("failed with seed %d: signature mismatch.", seed)
-	}
-	if decrypted.isAsymmetricEncryption() == symmetric {
-		t.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
-	}
-	if decrypted.isSymmetricEncryption() != symmetric {
-		t.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric)
-	}
-	if !symmetric {
-		if decrypted.Dst == nil {
-			t.Fatalf("failed with seed %d: dst is nil.", seed)
-		}
-		if !IsPubKeyEqual(decrypted.Dst, &key.PublicKey) {
-			t.Fatalf("failed with seed %d: Dst.", seed)
-		}
-	}
-}
-
-func TestEncryptWithZeroKey(t *testing.T) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.KeySym = make([]byte, aesKeyLength)
-	_, err = msg.Wrap(params)
-	if err == nil {
-		t.Fatalf("wrapped with zero key, seed: %d.", seed)
-	}
-
-	params, err = generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, err = NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.KeySym = make([]byte, 0)
-	_, err = msg.Wrap(params)
-	if err == nil {
-		t.Fatalf("wrapped with empty key, seed: %d.", seed)
-	}
-
-	params, err = generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, err = NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	params.KeySym = nil
-	_, err = msg.Wrap(params)
-	if err == nil {
-		t.Fatalf("wrapped with nil key, seed: %d.", seed)
-	}
-}
-
-func TestRlpEncode(t *testing.T) {
-	InitSingleTest()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("wrapped with zero key, seed: %d.", seed)
-	}
-
-	raw, err := rlp.EncodeToBytes(env)
-	if err != nil {
-		t.Fatalf("RLP encode failed: %s.", err)
-	}
-
-	var decoded Envelope
-	rlp.DecodeBytes(raw, &decoded)
-	if err != nil {
-		t.Fatalf("RLP decode failed: %s.", err)
-	}
-
-	he := env.Hash()
-	hd := decoded.Hash()
-
-	if he != hd {
-		t.Fatalf("Hashes are not equal: %x vs. %x", he, hd)
-	}
-}
-
-func singlePaddingTest(t *testing.T, padSize int) {
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d and sz=%d: %s.", seed, padSize, err)
-	}
-	params.Padding = make([]byte, padSize)
-	params.PoW = 0.0000000001
-	pad := make([]byte, padSize)
-	_, err = mrand.Read(pad)
-	if err != nil {
-		t.Fatalf("padding is not generated (seed %d): %s", seed, err)
-	}
-	n := copy(params.Padding, pad)
-	if n != padSize {
-		t.Fatalf("padding is not copied (seed %d): %s", seed, err)
-	}
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed to wrap, seed: %d and sz=%d.", seed, padSize)
-	}
-	f := Filter{KeySym: params.KeySym}
-	decrypted := env.Open(&f)
-	if decrypted == nil {
-		t.Fatalf("failed to open, seed and sz=%d: %d.", seed, padSize)
-	}
-	if !bytes.Equal(pad, decrypted.Padding) {
-		t.Fatalf("padding is not retireved as expected with seed %d and sz=%d:\n[%x]\n[%x].", seed, padSize, pad, decrypted.Padding)
-	}
-}
-
-func TestPadding(t *testing.T) {
-	InitSingleTest()
-
-	for i := 1; i < 260; i++ {
-		singlePaddingTest(t, i)
-	}
-
-	lim := 256 * 256
-	for i := lim - 5; i < lim+2; i++ {
-		singlePaddingTest(t, i)
-	}
-
-	for i := 0; i < 256; i++ {
-		n := mrand.Intn(256*254) + 256
-		singlePaddingTest(t, n)
-	}
-
-	for i := 0; i < 256; i++ {
-		n := mrand.Intn(256*1024) + 256*256
-		singlePaddingTest(t, n)
-	}
-}
-
-func TestPaddingAppendedToSymMessagesWithSignature(t *testing.T) {
-	params := &MessageParams{
-		Payload: make([]byte, 246),
-		KeySym:  make([]byte, aesKeyLength),
-	}
-
-	pSrc, err := crypto.GenerateKey()
-
-	if err != nil {
-		t.Fatalf("Error creating the signature key %v", err)
-		return
-	}
-	params.Src = pSrc
-
-	// Simulate a message with a payload just under 256 so that
-	// payload + flag + signature > 256. Check that the result
-	// is padded on the next 256 boundary.
-	msg := sentMessage{}
-	const payloadSizeFieldMinSize = 1
-	msg.Raw = make([]byte, flagsLength+payloadSizeFieldMinSize+len(params.Payload))
-
-	err = msg.appendPadding(params)
-
-	if err != nil {
-		t.Fatalf("Error appending padding to message %v", err)
-		return
-	}
-
-	if len(msg.Raw) != 512-signatureLength {
-		t.Errorf("Invalid size %d != 512", len(msg.Raw))
-	}
-}
-
-func TestAesNonce(t *testing.T) {
-	key := hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31")
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		t.Fatalf("NewCipher failed: %s", err)
-	}
-	aesgcm, err := cipher.NewGCM(block)
-	if err != nil {
-		t.Fatalf("NewGCM failed: %s", err)
-	}
-	// This is the most important single test in this package.
-	// If it fails, whisper will not be working.
-	if aesgcm.NonceSize() != aesNonceLength {
-		t.Fatalf("Nonce size is wrong. This is a critical error. Apparently AES nonce size have changed in the new version of AES GCM package. Whisper will not be working until this problem is resolved.")
-	}
-}

whisper/whisperv6/peer.go

@@ -1,268 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"fmt"
-	"math"
-	"sync"
-	"time"
-
-	mapset "github.com/deckarep/golang-set"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// Peer represents a whisper protocol peer connection.
-type Peer struct {
-	host *Whisper
-	peer *p2p.Peer
-	ws   p2p.MsgReadWriter
-
-	trusted        bool
-	powRequirement float64
-	bloomMu        sync.Mutex
-	bloomFilter    []byte
-	fullNode       bool
-
-	known mapset.Set // Messages already known by the peer to avoid wasting bandwidth
-
-	quit chan struct{}
-
-	wg sync.WaitGroup
-}
-
-// newPeer creates a new whisper peer object, but does not run the handshake itself.
-func newPeer(host *Whisper, remote *p2p.Peer, rw p2p.MsgReadWriter) *Peer {
-	return &Peer{
-		host:           host,
-		peer:           remote,
-		ws:             rw,
-		trusted:        false,
-		powRequirement: 0.0,
-		known:          mapset.NewSet(),
-		quit:           make(chan struct{}),
-		bloomFilter:    MakeFullNodeBloom(),
-		fullNode:       true,
-	}
-}
-
-// start initiates the peer updater, periodically broadcasting the whisper packets
-// into the network.
-func (peer *Peer) start() {
-	peer.wg.Add(1)
-	go peer.update()
-	log.Trace("start", "peer", peer.ID())
-}
-
-// stop terminates the peer updater, stopping message forwarding to it.
-func (peer *Peer) stop() {
-	close(peer.quit)
-	peer.wg.Wait()
-	log.Trace("stop", "peer", peer.ID())
-}
-
-// handshake sends the protocol initiation status message to the remote peer and
-// verifies the remote status too.
-func (peer *Peer) handshake() error {
-	// Send the handshake status message asynchronously
-	errc := make(chan error, 1)
-	isLightNode := peer.host.LightClientMode()
-	isRestrictedLightNodeConnection := peer.host.LightClientModeConnectionRestricted()
-	peer.wg.Add(1)
-	go func() {
-		defer peer.wg.Done()
-		pow := peer.host.MinPow()
-		powConverted := math.Float64bits(pow)
-		bloom := peer.host.BloomFilter()
-
-		errc <- p2p.SendItems(peer.ws, statusCode, ProtocolVersion, powConverted, bloom, isLightNode)
-	}()
-
-	// Fetch the remote status packet and verify protocol match
-	packet, err := peer.ws.ReadMsg()
-	if err != nil {
-		return err
-	}
-	if packet.Code != statusCode {
-		return fmt.Errorf("peer [%x] sent packet %x before status packet", peer.ID(), packet.Code)
-	}
-	s := rlp.NewStream(packet.Payload, uint64(packet.Size))
-	_, err = s.List()
-	if err != nil {
-		return fmt.Errorf("peer [%x] sent bad status message: %v", peer.ID(), err)
-	}
-	peerVersion, err := s.Uint()
-	if err != nil {
-		return fmt.Errorf("peer [%x] sent bad status message (unable to decode version): %v", peer.ID(), err)
-	}
-	if peerVersion != ProtocolVersion {
-		return fmt.Errorf("peer [%x]: protocol version mismatch %d != %d", peer.ID(), peerVersion, ProtocolVersion)
-	}
-
-	// only version is mandatory, subsequent parameters are optional
-	powRaw, err := s.Uint()
-	if err == nil {
-		pow := math.Float64frombits(powRaw)
-		if math.IsInf(pow, 0) || math.IsNaN(pow) || pow < 0.0 {
-			return fmt.Errorf("peer [%x] sent bad status message: invalid pow", peer.ID())
-		}
-		peer.powRequirement = pow
-
-		var bloom []byte
-		err = s.Decode(&bloom)
-		if err == nil {
-			sz := len(bloom)
-			if sz != BloomFilterSize && sz != 0 {
-				return fmt.Errorf("peer [%x] sent bad status message: wrong bloom filter size %d", peer.ID(), sz)
-			}
-			peer.setBloomFilter(bloom)
-		}
-	}
-
-	isRemotePeerLightNode, _ := s.Bool()
-	if isRemotePeerLightNode && isLightNode && isRestrictedLightNodeConnection {
-		return fmt.Errorf("peer [%x] is useless: two light client communication restricted", peer.ID())
-	}
-
-	if err := <-errc; err != nil {
-		return fmt.Errorf("peer [%x] failed to send status packet: %v", peer.ID(), err)
-	}
-	return nil
-}
-
-// update executes periodic operations on the peer, including message transmission
-// and expiration.
-func (peer *Peer) update() {
-	defer peer.wg.Done()
-	// Start the tickers for the updates
-	expire := time.NewTicker(expirationCycle)
-	defer expire.Stop()
-	transmit := time.NewTicker(transmissionCycle)
-	defer transmit.Stop()
-
-	// Loop and transmit until termination is requested
-	for {
-		select {
-		case <-expire.C:
-			peer.expire()
-
-		case <-transmit.C:
-			if err := peer.broadcast(); err != nil {
-				log.Trace("broadcast failed", "reason", err, "peer", peer.ID())
-				return
-			}
-
-		case <-peer.quit:
-			return
-		}
-	}
-}
-
-// mark marks an envelope known to the peer so that it won't be sent back.
-func (peer *Peer) mark(envelope *Envelope) {
-	peer.known.Add(envelope.Hash())
-}
-
-// marked checks if an envelope is already known to the remote peer.
-func (peer *Peer) marked(envelope *Envelope) bool {
-	return peer.known.Contains(envelope.Hash())
-}
-
-// expire iterates over all the known envelopes in the host and removes all
-// expired (unknown) ones from the known list.
-func (peer *Peer) expire() {
-	unmark := make(map[common.Hash]struct{})
-	peer.known.Each(func(v interface{}) bool {
-		if !peer.host.isEnvelopeCached(v.(common.Hash)) {
-			unmark[v.(common.Hash)] = struct{}{}
-		}
-		return true
-	})
-	// Dump all known but no longer cached
-	for hash := range unmark {
-		peer.known.Remove(hash)
-	}
-}
-
-// broadcast iterates over the collection of envelopes and transmits yet unknown
-// ones over the network.
-func (peer *Peer) broadcast() error {
-	envelopes := peer.host.Envelopes()
-	bundle := make([]*Envelope, 0, len(envelopes))
-	for _, envelope := range envelopes {
-		if !peer.marked(envelope) && envelope.PoW() >= peer.powRequirement && peer.bloomMatch(envelope) {
-			bundle = append(bundle, envelope)
-		}
-	}
-
-	if len(bundle) > 0 {
-		// transmit the batch of envelopes
-		if err := p2p.Send(peer.ws, messagesCode, bundle); err != nil {
-			return err
-		}
-
-		// mark envelopes only if they were successfully sent
-		for _, e := range bundle {
-			peer.mark(e)
-		}
-
-		log.Trace("broadcast", "num. messages", len(bundle))
-	}
-	return nil
-}
-
-// ID returns a peer's id
-func (peer *Peer) ID() []byte {
-	id := peer.peer.ID()
-	return id[:]
-}
-
-func (peer *Peer) notifyAboutPowRequirementChange(pow float64) error {
-	i := math.Float64bits(pow)
-	return p2p.Send(peer.ws, powRequirementCode, i)
-}
-
-func (peer *Peer) notifyAboutBloomFilterChange(bloom []byte) error {
-	return p2p.Send(peer.ws, bloomFilterExCode, bloom)
-}
-
-func (peer *Peer) bloomMatch(env *Envelope) bool {
-	peer.bloomMu.Lock()
-	defer peer.bloomMu.Unlock()
-	return peer.fullNode || BloomFilterMatch(peer.bloomFilter, env.Bloom())
-}
-
-func (peer *Peer) setBloomFilter(bloom []byte) {
-	peer.bloomMu.Lock()
-	defer peer.bloomMu.Unlock()
-	peer.bloomFilter = bloom
-	peer.fullNode = isFullNode(bloom)
-	if peer.fullNode && peer.bloomFilter == nil {
-		peer.bloomFilter = MakeFullNodeBloom()
-	}
-}
-
-func MakeFullNodeBloom() []byte {
-	bloom := make([]byte, BloomFilterSize)
-	for i := 0; i < BloomFilterSize; i++ {
-		bloom[i] = 0xFF
-	}
-	return bloom
-}

whisper/whisperv6/topic.go

@@ -1,56 +0,0 @@
-// Copyright 2016 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/>.
-
-// Contains the Whisper protocol Topic element.
-
-package whisperv6
-
-import (
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-// TopicType represents a cryptographically secure, probabilistic partial
-// classifications of a message, determined as the first (left) 4 bytes of the
-// SHA3 hash of some arbitrary data given by the original author of the message.
-type TopicType [TopicLength]byte
-
-// BytesToTopic converts from the byte array representation of a topic
-// into the TopicType type.
-func BytesToTopic(b []byte) (t TopicType) {
-	sz := TopicLength
-	if x := len(b); x < TopicLength {
-		sz = x
-	}
-	for i := 0; i < sz; i++ {
-		t[i] = b[i]
-	}
-	return t
-}
-
-// String converts a topic byte array to a string representation.
-func (t *TopicType) String() string {
-	return hexutil.Encode(t[:])
-}
-
-// MarshalText returns the hex representation of t.
-func (t TopicType) MarshalText() ([]byte, error) {
-	return hexutil.Bytes(t[:]).MarshalText()
-}
-
-// UnmarshalText parses a hex representation to a topic.
-func (t *TopicType) UnmarshalText(input []byte) error {
-	return hexutil.UnmarshalFixedText("Topic", input, t[:])
-}

whisper/whisperv6/topic_test.go

@@ -1,134 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-var topicStringTests = []struct {
-	topic TopicType
-	str   string
-}{
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, str: "0x00000000"},
-	{topic: TopicType{0x00, 0x7f, 0x80, 0xff}, str: "0x007f80ff"},
-	{topic: TopicType{0xff, 0x80, 0x7f, 0x00}, str: "0xff807f00"},
-	{topic: TopicType{0xf2, 0x6e, 0x77, 0x79}, str: "0xf26e7779"},
-}
-
-func TestTopicString(t *testing.T) {
-	for i, tst := range topicStringTests {
-		s := tst.topic.String()
-		if s != tst.str {
-			t.Fatalf("failed test %d: have %s, want %s.", i, s, tst.str)
-		}
-	}
-}
-
-var bytesToTopicTests = []struct {
-	data  []byte
-	topic TopicType
-}{
-	{topic: TopicType{0x8f, 0x9a, 0x2b, 0x7d}, data: []byte{0x8f, 0x9a, 0x2b, 0x7d}},
-	{topic: TopicType{0x00, 0x7f, 0x80, 0xff}, data: []byte{0x00, 0x7f, 0x80, 0xff}},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte{0x00, 0x00, 0x00, 0x00}},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte{0x00, 0x00, 0x00}},
-	{topic: TopicType{0x01, 0x00, 0x00, 0x00}, data: []byte{0x01}},
-	{topic: TopicType{0x00, 0xfe, 0x00, 0x00}, data: []byte{0x00, 0xfe}},
-	{topic: TopicType{0xea, 0x1d, 0x43, 0x00}, data: []byte{0xea, 0x1d, 0x43}},
-	{topic: TopicType{0x6f, 0x3c, 0xb0, 0xdd}, data: []byte{0x6f, 0x3c, 0xb0, 0xdd, 0x0f, 0x00, 0x90}},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte{}},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: nil},
-}
-
-var unmarshalTestsGood = []struct {
-	topic TopicType
-	data  []byte
-}{
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0x00000000"`)},
-	{topic: TopicType{0x00, 0x7f, 0x80, 0xff}, data: []byte(`"0x007f80ff"`)},
-	{topic: TopicType{0xff, 0x80, 0x7f, 0x00}, data: []byte(`"0xff807f00"`)},
-	{topic: TopicType{0xf2, 0x6e, 0x77, 0x79}, data: []byte(`"0xf26e7779"`)},
-}
-
-var unmarshalTestsBad = []struct {
-	topic TopicType
-	data  []byte
-}{
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0x000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0x0000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0x000000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0x0000000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"000000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"0000000000"`)},
-	{topic: TopicType{0x00, 0x00, 0x00, 0x00}, data: []byte(`"abcdefg0"`)},
-}
-
-var unmarshalTestsUgly = []struct {
-	topic TopicType
-	data  []byte
-}{
-	{topic: TopicType{0x01, 0x00, 0x00, 0x00}, data: []byte(`"0x00000001"`)},
-}
-
-func TestBytesToTopic(t *testing.T) {
-	for i, tst := range bytesToTopicTests {
-		top := BytesToTopic(tst.data)
-		if top != tst.topic {
-			t.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic)
-		}
-	}
-}
-
-func TestUnmarshalTestsGood(t *testing.T) {
-	for i, tst := range unmarshalTestsGood {
-		var top TopicType
-		err := json.Unmarshal(tst.data, &top)
-		if err != nil {
-			t.Errorf("failed test %d. input: %v. err: %v", i, tst.data, err)
-		} else if top != tst.topic {
-			t.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic)
-		}
-	}
-}
-
-func TestUnmarshalTestsBad(t *testing.T) {
-	// in this test UnmarshalJSON() is supposed to fail
-	for i, tst := range unmarshalTestsBad {
-		var top TopicType
-		err := json.Unmarshal(tst.data, &top)
-		if err == nil {
-			t.Fatalf("failed test %d. input: %v.", i, tst.data)
-		}
-	}
-}
-
-func TestUnmarshalTestsUgly(t *testing.T) {
-	// in this test UnmarshalJSON() is NOT supposed to fail, but result should be wrong
-	for i, tst := range unmarshalTestsUgly {
-		var top TopicType
-		err := json.Unmarshal(tst.data, &top)
-		if err != nil {
-			t.Errorf("failed test %d. input: %v.", i, tst.data)
-		} else if top == tst.topic {
-			t.Errorf("failed test %d: have %v, want %v.", i, top, tst.topic)
-		}
-	}
-}

whisper/whisperv6/whisper_test.go

@@ -1,928 +0,0 @@
-// Copyright 2016 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/>.
-
-package whisperv6
-
-import (
-	"bytes"
-	"crypto/ecdsa"
-	"crypto/sha256"
-	mrand "math/rand"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/node"
-	"golang.org/x/crypto/pbkdf2"
-)
-
-func TestWhisperBasic(t *testing.T) {
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	shh := w.Protocols()[0]
-	if shh.Name != ProtocolName {
-		t.Fatalf("failed Protocol Name: %v.", shh.Name)
-	}
-	if uint64(shh.Version) != ProtocolVersion {
-		t.Fatalf("failed Protocol Version: %v.", shh.Version)
-	}
-	if shh.Length != NumberOfMessageCodes {
-		t.Fatalf("failed Protocol Length: %v.", shh.Length)
-	}
-	if shh.Run == nil {
-		t.Fatal("failed shh.Run.")
-	}
-	if uint64(w.Version()) != ProtocolVersion {
-		t.Fatalf("failed whisper Version: %v.", shh.Version)
-	}
-	if w.GetFilter("non-existent") != nil {
-		t.Fatal("failed GetFilter.")
-	}
-
-	peerID := make([]byte, 64)
-	mrand.Read(peerID)
-	peer, _ := w.getPeer(peerID)
-	if peer != nil {
-		t.Fatal("found peer for random key.")
-	}
-	if err := w.AllowP2PMessagesFromPeer(peerID); err == nil {
-		t.Fatal("failed MarkPeerTrusted.")
-	}
-	exist := w.HasSymKey("non-existing")
-	if exist {
-		t.Fatal("failed HasSymKey.")
-	}
-	key, err := w.GetSymKey("non-existing")
-	if err == nil {
-		t.Fatalf("failed GetSymKey(non-existing): false positive. key=%v", key)
-	}
-	if key != nil {
-		t.Fatalf("failed GetSymKey: false positive. key=%v", key)
-	}
-	mail := w.Envelopes()
-	if len(mail) != 0 {
-		t.Fatalf("failed w.Envelopes(). length=%d", len(mail))
-	}
-
-	derived := pbkdf2.Key(peerID, nil, 65356, aesKeyLength, sha256.New)
-	if !validateDataIntegrity(derived, aesKeyLength) {
-		t.Fatalf("failed validateSymmetricKey with param = %v.", derived)
-	}
-	if containsOnlyZeros(derived) {
-		t.Fatalf("failed containsOnlyZeros with param = %v.", derived)
-	}
-
-	buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0}
-	le := bytesToUintLittleEndian(buf)
-	be := BytesToUintBigEndian(buf)
-	if le != uint64(0x280e5ff) {
-		t.Fatalf("failed bytesToIntLittleEndian: %d.", le)
-	}
-	if be != uint64(0xffe5800200) {
-		t.Fatalf("failed BytesToIntBigEndian: %d.", be)
-	}
-
-	id, err := w.NewKeyPair()
-	if err != nil {
-		t.Fatalf("failed to generate new key pair: %v.", err)
-	}
-	pk, err := w.GetPrivateKey(id)
-	if err != nil {
-		t.Fatalf("failed to retrieve new key pair: %v.", err)
-	}
-	if !validatePrivateKey(pk) {
-		t.Fatalf("failed validatePrivateKey: %v.", pk)
-	}
-	if !ValidatePublicKey(&pk.PublicKey) {
-		t.Fatalf("failed ValidatePublicKey: %v.", pk)
-	}
-}
-
-func TestWhisperAsymmetricKeyImport(t *testing.T) {
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	var privateKeys []*ecdsa.PrivateKey
-	for i := 0; i < 50; i++ {
-		id, err := w.NewKeyPair()
-		if err != nil {
-			t.Fatalf("could not generate key: %v", err)
-		}
-
-		pk, err := w.GetPrivateKey(id)
-		if err != nil {
-			t.Fatalf("could not export private key: %v", err)
-		}
-
-		privateKeys = append(privateKeys, pk)
-
-		if !w.DeleteKeyPair(id) {
-			t.Fatal("could not delete private key")
-		}
-	}
-
-	for _, pk := range privateKeys {
-		if _, err := w.AddKeyPair(pk); err != nil {
-			t.Fatalf("could not import private key: %v", err)
-		}
-	}
-}
-
-func TestWhisperIdentityManagement(t *testing.T) {
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	id1, err := w.NewKeyPair()
-	if err != nil {
-		t.Fatalf("failed to generate new key pair: %s.", err)
-	}
-	id2, err := w.NewKeyPair()
-	if err != nil {
-		t.Fatalf("failed to generate new key pair: %s.", err)
-	}
-	pk1, err := w.GetPrivateKey(id1)
-	if err != nil {
-		t.Fatalf("failed to retrieve the key pair: %s.", err)
-	}
-	pk2, err := w.GetPrivateKey(id2)
-	if err != nil {
-		t.Fatalf("failed to retrieve the key pair: %s.", err)
-	}
-
-	if !w.HasKeyPair(id1) {
-		t.Fatal("failed HasIdentity(pk1).")
-	}
-	if !w.HasKeyPair(id2) {
-		t.Fatal("failed HasIdentity(pk2).")
-	}
-	if pk1 == nil {
-		t.Fatal("failed GetIdentity(pk1).")
-	}
-	if pk2 == nil {
-		t.Fatal("failed GetIdentity(pk2).")
-	}
-
-	if !validatePrivateKey(pk1) {
-		t.Fatal("pk1 is invalid.")
-	}
-	if !validatePrivateKey(pk2) {
-		t.Fatal("pk2 is invalid.")
-	}
-
-	// Delete one identity
-	done := w.DeleteKeyPair(id1)
-	if !done {
-		t.Fatal("failed to delete id1.")
-	}
-	pk1, err = w.GetPrivateKey(id1)
-	if err == nil {
-		t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
-	}
-	pk2, err = w.GetPrivateKey(id2)
-	if err != nil {
-		t.Fatalf("failed to retrieve the key pair: %s.", err)
-	}
-	if w.HasKeyPair(id1) {
-		t.Fatal("failed DeleteIdentity(pub1): still exist.")
-	}
-	if !w.HasKeyPair(id2) {
-		t.Fatal("failed DeleteIdentity(pub1): pub2 does not exist.")
-	}
-	if pk1 != nil {
-		t.Fatal("failed DeleteIdentity(pub1): first key still exist.")
-	}
-	if pk2 == nil {
-		t.Fatal("failed DeleteIdentity(pub1): second key does not exist.")
-	}
-
-	// Delete again non-existing identity
-	done = w.DeleteKeyPair(id1)
-	if done {
-		t.Fatal("delete id1: false positive.")
-	}
-	pk1, err = w.GetPrivateKey(id1)
-	if err == nil {
-		t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
-	}
-	pk2, err = w.GetPrivateKey(id2)
-	if err != nil {
-		t.Fatalf("failed to retrieve the key pair: %s.", err)
-	}
-	if w.HasKeyPair(id1) {
-		t.Fatal("failed delete non-existing identity: exist.")
-	}
-	if !w.HasKeyPair(id2) {
-		t.Fatal("failed delete non-existing identity: pub2 does not exist.")
-	}
-	if pk1 != nil {
-		t.Fatalf("failed delete non-existing identity: first key exist. key=%v", pk1)
-	}
-	if pk2 == nil {
-		t.Fatal("failed delete non-existing identity: second key does not exist.")
-	}
-
-	// Delete second identity
-	done = w.DeleteKeyPair(id2)
-	if !done {
-		t.Fatal("failed to delete id2.")
-	}
-	pk1, err = w.GetPrivateKey(id1)
-	if err == nil {
-		t.Fatalf("retrieve the key pair: false positive. key=%v", pk1)
-	}
-	pk2, err = w.GetPrivateKey(id2)
-	if err == nil {
-		t.Fatalf("retrieve the key pair: false positive. key=%v", pk2)
-	}
-	if w.HasKeyPair(id1) {
-		t.Fatal("failed delete second identity: first identity exist.")
-	}
-	if w.HasKeyPair(id2) {
-		t.Fatal("failed delete second identity: still exist.")
-	}
-	if pk1 != nil {
-		t.Fatalf("failed delete second identity: first key exist. key=%v", pk1)
-	}
-	if pk2 != nil {
-		t.Fatalf("failed delete second identity: second key exist. key=%v", pk2)
-	}
-}
-
-func TestWhisperSymKeyManagement(t *testing.T) {
-	InitSingleTest()
-	var (
-		k1, k2 []byte
-		id2    = string("arbitrary-string-2")
-	)
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	id1, err := w.GenerateSymKey()
-	if err != nil {
-		t.Fatalf("failed GenerateSymKey with seed %d: %s.", seed, err)
-	}
-
-	k1, err = w.GetSymKey(id1)
-	if err != nil {
-		t.Fatalf("failed GetSymKey(id1). err=%v", err)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err == nil {
-		t.Fatalf("failed GetSymKey(id2): false positive. key=%v", k2)
-	}
-	if !w.HasSymKey(id1) {
-		t.Fatal("failed HasSymKey(id1).")
-	}
-	if w.HasSymKey(id2) {
-		t.Fatal("failed HasSymKey(id2): false positive.")
-	}
-	if k1 == nil {
-		t.Fatal("first key does not exist.")
-	}
-	if k2 != nil {
-		t.Fatalf("second key still exist. key=%v", k2)
-	}
-
-	// add existing id, nothing should change
-	randomKey := make([]byte, aesKeyLength)
-	mrand.Read(randomKey)
-	id1, err = w.AddSymKeyDirect(randomKey)
-	if err != nil {
-		t.Fatalf("failed AddSymKey with seed %d: %s.", seed, err)
-	}
-
-	k1, err = w.GetSymKey(id1)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err == nil {
-		t.Fatalf("failed w.GetSymKey(id2): false positive. key=%v", k2)
-	}
-	if !w.HasSymKey(id1) {
-		t.Fatal("failed w.HasSymKey(id1).")
-	}
-	if w.HasSymKey(id2) {
-		t.Fatal("failed w.HasSymKey(id2): false positive.")
-	}
-	if k1 == nil {
-		t.Fatal("first key does not exist.")
-	}
-	if !bytes.Equal(k1, randomKey) {
-		t.Fatal("k1 != randomKey.")
-	}
-	if k2 != nil {
-		t.Fatalf("second key already exist. key=%v", k2)
-	}
-
-	id2, err = w.AddSymKeyDirect(randomKey)
-	if err != nil {
-		t.Fatalf("failed AddSymKey(id2) with seed %d: %s.", seed, err)
-	}
-	k1, err = w.GetSymKey(id1)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
-	}
-	if !w.HasSymKey(id1) {
-		t.Fatal("HasSymKey(id1) failed.")
-	}
-	if !w.HasSymKey(id2) {
-		t.Fatal("HasSymKey(id2) failed.")
-	}
-	if k1 == nil {
-		t.Fatal("k1 does not exist.")
-	}
-	if k2 == nil {
-		t.Fatal("k2 does not exist.")
-	}
-	if !bytes.Equal(k1, k2) {
-		t.Fatal("k1 != k2.")
-	}
-	if !bytes.Equal(k1, randomKey) {
-		t.Fatal("k1 != randomKey.")
-	}
-	if len(k1) != aesKeyLength {
-		t.Fatalf("wrong length of k1. length=%d", len(k1))
-	}
-	if len(k2) != aesKeyLength {
-		t.Fatalf("wrong length of k2. length=%d", len(k2))
-	}
-
-	w.DeleteSymKey(id1)
-	k1, err = w.GetSymKey(id1)
-	if err == nil {
-		t.Fatal("failed w.GetSymKey(id1): false positive.")
-	}
-	if k1 != nil {
-		t.Fatalf("failed GetSymKey(id1): false positive. key=%v", k1)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
-	}
-	if w.HasSymKey(id1) {
-		t.Fatal("failed to delete first key: still exist.")
-	}
-	if !w.HasSymKey(id2) {
-		t.Fatal("failed to delete first key: second key does not exist.")
-	}
-	if k2 == nil {
-		t.Fatal("failed to delete first key: second key is nil.")
-	}
-
-	w.DeleteSymKey(id1)
-	w.DeleteSymKey(id2)
-	k1, err = w.GetSymKey(id1)
-	if err == nil {
-		t.Fatalf("failed w.GetSymKey(id1): false positive. key=%v", k1)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err == nil {
-		t.Fatalf("failed w.GetSymKey(id2): false positive. key=%v", k2)
-	}
-	if k1 != nil || k2 != nil {
-		t.Fatal("k1 or k2 is not nil")
-	}
-	if w.HasSymKey(id1) {
-		t.Fatal("failed to delete second key: first key exist.")
-	}
-	if w.HasSymKey(id2) {
-		t.Fatal("failed to delete second key: still exist.")
-	}
-	if k1 != nil {
-		t.Fatal("failed to delete second key: first key is not nil.")
-	}
-	if k2 != nil {
-		t.Fatal("failed to delete second key: second key is not nil.")
-	}
-
-	randomKey = make([]byte, aesKeyLength+1)
-	mrand.Read(randomKey)
-	_, err = w.AddSymKeyDirect(randomKey)
-	if err == nil {
-		t.Fatalf("added the key with wrong size, seed %d.", seed)
-	}
-
-	const password = "arbitrary data here"
-	id1, err = w.AddSymKeyFromPassword(password)
-	if err != nil {
-		t.Fatalf("failed AddSymKeyFromPassword(id1) with seed %d: %s.", seed, err)
-	}
-	id2, err = w.AddSymKeyFromPassword(password)
-	if err != nil {
-		t.Fatalf("failed AddSymKeyFromPassword(id2) with seed %d: %s.", seed, err)
-	}
-	k1, err = w.GetSymKey(id1)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id1). err=%v", err)
-	}
-	k2, err = w.GetSymKey(id2)
-	if err != nil {
-		t.Fatalf("failed w.GetSymKey(id2). err=%v", err)
-	}
-	if !w.HasSymKey(id1) {
-		t.Fatal("HasSymKey(id1) failed.")
-	}
-	if !w.HasSymKey(id2) {
-		t.Fatal("HasSymKey(id2) failed.")
-	}
-	if !validateDataIntegrity(k2, aesKeyLength) {
-		t.Fatal("key validation failed.")
-	}
-	if !bytes.Equal(k1, k2) {
-		t.Fatal("k1 != k2.")
-	}
-}
-
-func TestExpiry(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	w.SetMinimumPowTest(0.0000001)
-	defer w.SetMinimumPowTest(DefaultMinimumPoW)
-	w.Start()
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	params.TTL = 1
-
-	messagesCount := 5
-
-	// Send a few messages one after another. Due to low PoW and expiration buckets
-	// with one second resolution, it covers a case when there are multiple items
-	// in a single expiration bucket.
-	for i := 0; i < messagesCount; i++ {
-		msg, err := NewSentMessage(params)
-		if err != nil {
-			t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-		}
-		env, err := msg.Wrap(params)
-		if err != nil {
-			t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-		}
-
-		err = w.Send(env)
-		if err != nil {
-			t.Fatalf("failed to send envelope with seed %d: %s.", seed, err)
-		}
-	}
-
-	// wait till received or timeout
-	var received, expired bool
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-	for j := 0; j < 20; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) == messagesCount {
-			received = true
-			break
-		}
-	}
-
-	if !received {
-		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
-	}
-
-	// wait till expired or timeout
-	for j := 0; j < 20; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) == 0 {
-			expired = true
-			break
-		}
-	}
-
-	if !expired {
-		t.Fatalf("expire failed, seed: %d.", seed)
-	}
-}
-
-func TestCustomization(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	defer w.SetMinimumPowTest(DefaultMinimumPoW)
-	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
-	w.Start()
-
-	const smallPoW = 0.00001
-
-	f, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	params.KeySym = f.KeySym
-	params.Topic = BytesToTopic(f.Topics[2])
-	params.PoW = smallPoW
-	params.TTL = 3600 * 24 // one day
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	err = w.Send(env)
-	if err == nil {
-		t.Fatalf("successfully sent envelope with PoW %.06f, false positive (seed %d).", env.PoW(), seed)
-	}
-
-	w.SetMinimumPowTest(smallPoW / 2)
-	err = w.Send(env)
-	if err != nil {
-		t.Fatalf("failed to send envelope with seed %d: %s.", seed, err)
-	}
-
-	params.TTL++
-	msg, err = NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err = msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-	w.SetMaxMessageSize(uint32(env.size() - 1))
-	err = w.Send(env)
-	if err == nil {
-		t.Fatalf("successfully sent oversized envelope (seed %d): false positive.", seed)
-	}
-
-	w.SetMaxMessageSize(DefaultMaxMessageSize)
-	err = w.Send(env)
-	if err != nil {
-		t.Fatalf("failed to send second envelope with seed %d: %s.", seed, err)
-	}
-
-	// wait till received or timeout
-	var received bool
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-	for j := 0; j < 20; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) > 1 {
-			received = true
-			break
-		}
-	}
-
-	if !received {
-		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
-	}
-
-	// check w.messages()
-	_, err = w.Subscribe(f)
-	if err != nil {
-		t.Fatalf("failed subscribe with seed %d: %s.", seed, err)
-	}
-	<-ticker.C
-	mail := f.Retrieve()
-	if len(mail) > 0 {
-		t.Fatalf("received premature mail. mail=%v", mail)
-	}
-}
-
-func TestSymmetricSendCycle(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	defer w.SetMinimumPowTest(DefaultMinimumPoW)
-	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
-	w.Start()
-
-	filter1, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	filter1.PoW = DefaultMinimumPoW
-
-	// Copy the first filter since some of its fields
-	// are randomly gnerated.
-	filter2 := &Filter{
-		KeySym:   filter1.KeySym,
-		Topics:   filter1.Topics,
-		PoW:      filter1.PoW,
-		AllowP2P: filter1.AllowP2P,
-		Messages: make(map[common.Hash]*ReceivedMessage),
-	}
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	filter1.Src = &params.Src.PublicKey
-	filter2.Src = &params.Src.PublicKey
-
-	params.KeySym = filter1.KeySym
-	params.Topic = BytesToTopic(filter1.Topics[2])
-	params.PoW = filter1.PoW
-	params.WorkTime = 10
-	params.TTL = 50
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	_, err = w.Subscribe(filter1)
-	if err != nil {
-		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
-	}
-
-	_, err = w.Subscribe(filter2)
-	if err != nil {
-		t.Fatalf("failed subscribe 2 with seed %d: %s.", seed, err)
-	}
-
-	err = w.Send(env)
-	if err != nil {
-		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
-	}
-
-	// wait till received or timeout
-	var received bool
-	ticker := time.NewTicker(10 * time.Millisecond)
-	defer ticker.Stop()
-	for j := 0; j < 200; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) > 0 {
-			received = true
-			break
-		}
-	}
-
-	if !received {
-		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
-	}
-
-	// check w.messages()
-	<-ticker.C
-	mail1 := filter1.Retrieve()
-	mail2 := filter2.Retrieve()
-	if len(mail2) == 0 {
-		t.Fatal("did not receive any email for filter 2.")
-	}
-	if len(mail1) == 0 {
-		t.Fatal("did not receive any email for filter 1.")
-	}
-
-}
-
-func TestSymmetricSendWithoutAKey(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	defer w.SetMinimumPowTest(DefaultMinimumPoW)
-	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
-	w.Start()
-
-	filter, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	filter.PoW = DefaultMinimumPoW
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	filter.Src = nil
-
-	params.KeySym = filter.KeySym
-	params.Topic = BytesToTopic(filter.Topics[2])
-	params.PoW = filter.PoW
-	params.WorkTime = 10
-	params.TTL = 50
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	_, err = w.Subscribe(filter)
-	if err != nil {
-		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
-	}
-
-	err = w.Send(env)
-	if err != nil {
-		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
-	}
-
-	// wait till received or timeout
-	var received bool
-	ticker := time.NewTicker(10 * time.Millisecond)
-	defer ticker.Stop()
-	for j := 0; j < 200; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) > 0 {
-			received = true
-			break
-		}
-	}
-
-	if !received {
-		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
-	}
-
-	// check w.messages()
-	<-ticker.C
-	mail := filter.Retrieve()
-	if len(mail) == 0 {
-		t.Fatal("did not receive message in spite of not setting a public key")
-	}
-}
-
-func TestSymmetricSendKeyMismatch(t *testing.T) {
-	InitSingleTest()
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	defer w.SetMinimumPowTest(DefaultMinimumPoW)
-	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
-	w.Start()
-
-	filter, err := generateFilter(t, true)
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-	filter.PoW = DefaultMinimumPoW
-
-	params, err := generateMessageParams()
-	if err != nil {
-		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
-	}
-
-	params.KeySym = filter.KeySym
-	params.Topic = BytesToTopic(filter.Topics[2])
-	params.PoW = filter.PoW
-	params.WorkTime = 10
-	params.TTL = 50
-	msg, err := NewSentMessage(params)
-	if err != nil {
-		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
-	}
-	env, err := msg.Wrap(params)
-	if err != nil {
-		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
-	}
-
-	_, err = w.Subscribe(filter)
-	if err != nil {
-		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
-	}
-
-	err = w.Send(env)
-	if err != nil {
-		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
-	}
-
-	// wait till received or timeout
-	var received bool
-	ticker := time.NewTicker(10 * time.Millisecond)
-	defer ticker.Stop()
-	for j := 0; j < 200; j++ {
-		<-ticker.C
-		if len(w.Envelopes()) > 0 {
-			received = true
-			break
-		}
-	}
-
-	if !received {
-		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
-	}
-
-	// check w.messages()
-	<-ticker.C
-	mail := filter.Retrieve()
-	if len(mail) > 0 {
-		t.Fatalf("received a message when keys weren't matching. message=%v", mail)
-	}
-}
-
-func TestBloom(t *testing.T) {
-	topic := TopicType{0, 0, 255, 6}
-	b := TopicToBloom(topic)
-	x := make([]byte, BloomFilterSize)
-	x[0] = byte(1)
-	x[32] = byte(1)
-	x[BloomFilterSize-1] = byte(128)
-	if !BloomFilterMatch(x, b) || !BloomFilterMatch(b, x) {
-		t.Fatal("bloom filter does not match the mask")
-	}
-
-	_, err := mrand.Read(b)
-	if err != nil {
-		t.Fatalf("math rand error. err=%v", err)
-	}
-	_, err = mrand.Read(x)
-	if err != nil {
-		t.Fatalf("math rand error. err=%v", err)
-	}
-	if !BloomFilterMatch(b, b) {
-		t.Fatal("bloom filter does not match self")
-	}
-	x = addBloom(x, b)
-	if !BloomFilterMatch(x, b) {
-		t.Fatal("bloom filter does not match combined bloom")
-	}
-	if !isFullNode(nil) {
-		t.Fatal("isFullNode did not recognize nil as full node")
-	}
-	x[17] = 254
-	if isFullNode(x) {
-		t.Fatal("isFullNode false positive")
-	}
-	for i := 0; i < BloomFilterSize; i++ {
-		b[i] = byte(255)
-	}
-	if !isFullNode(b) {
-		t.Fatal("isFullNode false negative")
-	}
-	if BloomFilterMatch(x, b) {
-		t.Fatal("bloomFilterMatch false positive")
-	}
-	if !BloomFilterMatch(b, x) {
-		t.Fatal("bloomFilterMatch false negative")
-	}
-
-	stack, w := newNodeWithWhisper(t)
-	defer stack.Close()
-
-	f := w.BloomFilter()
-	if f != nil {
-		t.Fatal("wrong bloom on creation")
-	}
-	err = w.SetBloomFilter(x)
-	if err != nil {
-		t.Fatalf("failed to set bloom filter: %v", err)
-	}
-	f = w.BloomFilter()
-	if !BloomFilterMatch(f, x) || !BloomFilterMatch(x, f) {
-		t.Fatal("retireved wrong bloom filter")
-	}
-}
-
-// newNodeWithWhisper creates a new node using a default config and
-// creates and registers a new Whisper service on it.
-func newNodeWithWhisper(t *testing.T) (*node.Node, *Whisper) {
-	stack, err := node.New(&node.DefaultConfig)
-	if err != nil {
-		t.Fatalf("could not create new node: %v", err)
-	}
-	w, err := New(stack, &DefaultConfig)
-	if err != nil {
-		t.Fatalf("could not create new whisper service: %v", err)
-	}
-	err = stack.Start()
-	if err != nil {
-		t.Fatalf("could not start node: %v", err)
-	}
-	return stack, w
-}