mirror of https://github.com/ethereum/go-ethereum
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>pull/21678/head
Guillaume Ballet
4 years ago
committed by
GitHub
parent
c5d28f0b27
commit
d54f2f2e5e
@ -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(¶ms) |
||||
if err != nil { |
||||
utils.Fatalf("failed to create new message: %s", err) |
||||
} |
||||
|
||||
envelope, err := msg.Wrap(¶ms) |
||||
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(¶ms) |
||||
if err != nil { |
||||
utils.Fatalf("failed to create new message: %s", err) |
||||
} |
||||
env, err := msg.Wrap(¶ms) |
||||
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
|
||||
} |
||||
} |
||||
@ -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 |
||||
} |
||||
Binary file not shown.
@ -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, ¶msDecoded) |
||||
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(¶ms) |
||||
if err != nil { |
||||
panic(err) |
||||
//return
|
||||
} |
||||
env, err := msg.Wrap(¶ms) |
||||
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, ¶ms.Src.PublicKey) { |
||||
panic("Unexpected public key") |
||||
} |
||||
return 0 |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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) |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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") |
||||
} |
||||
} |
||||
@ -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) |
||||
} |
||||
} |
||||
} |
||||
@ -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, |
||||
} |
||||
@ -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) |
||||
} |
||||
@ -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] |
||||
} |
||||
@ -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(¶ms) |
||||
if err != nil { |
||||
t.Fatalf("failed to create new message with seed %d: %s.", seed, err) |
||||
} |
||||
|
||||
e, err := msg.Wrap(¶ms) |
||||
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) |
||||
} |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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 = ¶ms.Src.PublicKey |
||||
filter2.Src = ¶ms.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) |
||||
} |
||||
} |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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) |
||||
} |
||||
@ -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, ¶ms.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, ¶ms.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.") |
||||
} |
||||
} |
||||
@ -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 |
||||
} |
||||
@ -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[:]) |
||||
} |
||||
@ -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) |
||||
} |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -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 = ¶ms.Src.PublicKey |
||||
filter2.Src = ¶ms.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 |
||||
} |
||||
Loading…
Reference in new issue