mirror/erigon-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/erigon-pulse.git synced 2024-12-23 04:03:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Whisper API fixed (#3687)

Browse Source 
* whisper: wnode updated for tests with geth

* whisper: updated processing of incoming messages

* whisper: symmetric encryption updated

* whisper: filter id type changed to enhance security

* whisper: allow filter without topic for asymmetric encryption

* whisper: POW updated

* whisper: logging updated

* whisper: spellchecker update

* whisper: error handling changed

* whisper: JSON field names fixed
This commit is contained in:
gluk256 2017-02-23 09:41:47 +01:00 committed by Jeffrey Wilcke
parent 555273495b
commit 29fac7de44
11 changed files with 182 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
cmd/wnode/main.go
View File

@ -22,8 +22,6 @@ package main
import (
"bufio"
"crypto/ecdsa"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
"encoding/binary"
"encoding/hex"
@ -49,6 +47,7 @@ import (
)
const quitCommand = "~Q"
const symKeyName = "da919ea33001b04dfc630522e33078ec0df11"
// singletons
var (
@ -67,7 +66,8 @@ var (
asymKey *ecdsa.PrivateKey
nodeid *ecdsa.PrivateKey
topic whisper.TopicType
filterID uint32
filterID string
symPass string
msPassword string
)
@ -82,13 +82,13 @@ var (
testMode = flag.Bool("t", false, "use of predefined parameters for diagnostics")
generateKey = flag.Bool("k", false, "generate and show the private key")
argVerbosity = flag.Int("verbosity", logger.Warn, "log verbosity level")
argTTL = flag.Uint("ttl", 30, "time-to-live for messages in seconds")
argWorkTime = flag.Uint("work", 5, "work time in seconds")
argPoW = flag.Float64("pow", whisper.MinimumPoW, "PoW for normal messages in float format (e.g. 2.7)")
argServerPoW = flag.Float64("mspow", whisper.MinimumPoW, "PoW requirement for Mail Server request")
argIP = flag.String("ip", "", "IP address and port of this node (e.g. 127.0.0.1:30303)")
argSalt = flag.String("salt", "", "salt (for topic and key derivation)")
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)")
@ -146,7 +146,6 @@ func echo() {
fmt.Printf("pow = %f \n", *argPoW)
fmt.Printf("mspow = %f \n", *argServerPoW)
fmt.Printf("ip = %s \n", *argIP)
fmt.Printf("salt = %s \n", *argSalt)
fmt.Printf("pub = %s \n", common.ToHex(crypto.FromECDSAPub(pub)))
fmt.Printf("idfile = %s \n", *argIDFile)
fmt.Printf("dbpath = %s \n", *argDBPath)
@ -154,7 +153,7 @@ func echo() {
}
func initialize() {
glog.SetV(logger.Warn)
glog.SetV(*argVerbosity)
glog.SetToStderr(true)
done = make(chan struct{})
@ -172,10 +171,7 @@ func initialize() {
}
if *testMode {
password := []byte("test password for symmetric encryption")
salt := []byte("test salt for symmetric encryption")
symKey = pbkdf2.Key(password, salt, 64, 32, sha256.New)
topic = whisper.TopicType{0xFF, 0xFF, 0xFF, 0xFF}
symPass = "wwww" // ascii code: 0x77777777
msPassword = "mail server test password"
}
@ -286,20 +282,18 @@ func configureNode() {
}
}
if !*asymmetricMode && !*forwarderMode && !*testMode {
pass, err := console.Stdin.PromptPassword("Please enter the password: ")
if err != nil {
utils.Fatalf("Failed to read passphrase: %v", err)
if !*asymmetricMode && !*forwarderMode {
if len(symPass) == 0 {
symPass, err = console.Stdin.PromptPassword("Please enter the password: ")
if err != nil {
utils.Fatalf("Failed to read passphrase: %v", err)
}
}
if len(*argSalt) == 0 {
argSalt = scanLineA("Please enter the salt: ")
}
symKey = pbkdf2.Key([]byte(pass), []byte(*argSalt), 65356, 32, sha256.New)
shh.AddSymKey(symKeyName, []byte(symPass))
symKey = shh.GetSymKey(symKeyName)
if len(*argTopic) == 0 {
generateTopic([]byte(pass), []byte(*argSalt))
generateTopic([]byte(symPass))
}
}
@ -315,19 +309,17 @@ func configureNode() {
Topics: []whisper.TopicType{topic},
AcceptP2P: p2pAccept,
}
filterID = shh.Watch(&filter)
filterID, err = shh.Watch(&filter)
if err != nil {
utils.Fatalf("Failed to install filter: %s", err)
}
fmt.Printf("Filter is configured for the topic: %x \n", topic)
}
func generateTopic(password, salt []byte) {
const rounds = 4000
const size = 128
x1 := pbkdf2.Key(password, salt, rounds, size, sha512.New)
x2 := pbkdf2.Key(password, salt, rounds, size, sha1.New)
x3 := pbkdf2.Key(x1, x2, rounds, size, sha256.New)
for i := 0; i < size; i++ {
topic[i%whisper.TopicLength] ^= x3[i]
func generateTopic(password []byte) {
x := pbkdf2.Key(password, password, 8196, 128, sha512.New)
for i := 0; i < len(x); i++ {
topic[i%whisper.TopicLength] ^= x[i]
}
}
@ -379,9 +371,9 @@ func sendLoop() {
if *asymmetricMode {
// print your own message for convenience,
// because in asymmetric mode it is impossible to decrypt it
hour, min, sec := time.Now().Clock()
timestamp := time.Now().Unix()
from := crypto.PubkeyToAddress(asymKey.PublicKey)
fmt.Printf("\n%02d:%02d:%02d <%x>: %s\n", hour, min, sec, from, s)
fmt.Printf("\n%d <%x>: %s\n", timestamp, from, s)
}
}
}

73
whisper/whisperv5/api.go
View File

@ -123,7 +123,7 @@ func (api *PublicWhisperAPI) GenerateSymKey(name string) error {
}
// AddSymKey stores the key under the 'name' id.
func (api *PublicWhisperAPI) AddSymKey(name string, key []byte) error {
func (api *PublicWhisperAPI) AddSymKey(name string, key hexutil.Bytes) error {
if api.whisper == nil {
return whisperOffLineErr
}
@ -151,9 +151,9 @@ func (api *PublicWhisperAPI) DeleteSymKey(name string) error {
// NewWhisperFilter creates and registers a new message filter to watch for inbound whisper messages.
// Returns the ID of the newly created Filter.
func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (uint32, error) {
func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (string, error) {
if api.whisper == nil {
return 0, whisperOffLineErr
return "", whisperOffLineErr
}
filter := Filter{
@ -168,28 +168,28 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (uint32, error) {
}
filter.Topics = append(filter.Topics, args.Topics...)
if len(args.Topics) == 0 {
if len(args.Topics) == 0 && len(args.KeyName) != 0 {
info := "NewFilter: at least one topic must be specified"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
if len(args.KeyName) != 0 && len(filter.KeySym) == 0 {
info := "NewFilter: key was not found by name: " + args.KeyName
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
if len(args.To) == 0 && len(filter.KeySym) == 0 {
info := "NewFilter: filter must contain either symmetric or asymmetric key"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
if len(args.To) != 0 && len(filter.KeySym) != 0 {
info := "NewFilter: filter must not contain both symmetric and asymmetric key"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
if len(args.To) > 0 {
@ -197,13 +197,13 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (uint32, error) {
if !ValidatePublicKey(dst) {
info := "NewFilter: Invalid 'To' address"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
filter.KeyAsym = api.whisper.GetIdentity(string(args.To))
if filter.KeyAsym == nil {
info := "NewFilter: non-existent identity provided"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
}
@ -211,21 +211,20 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (uint32, error) {
if !ValidatePublicKey(filter.Src) {
info := "NewFilter: Invalid 'From' address"
glog.V(logger.Error).Infof(info)
return 0, errors.New(info)
return "", errors.New(info)
}
}
id := api.whisper.Watch(&filter)
return id, nil
return api.whisper.Watch(&filter)
}
// UninstallFilter disables and removes an existing filter.
func (api *PublicWhisperAPI) UninstallFilter(filterId uint32) {
func (api *PublicWhisperAPI) UninstallFilter(filterId string) {
api.whisper.Unwatch(filterId)
}
// GetFilterChanges retrieves all the new messages matched by a filter since the last retrieval.
func (api *PublicWhisperAPI) GetFilterChanges(filterId uint32) []WhisperMessage {
func (api *PublicWhisperAPI) GetFilterChanges(filterId string) []*WhisperMessage {
f := api.whisper.GetFilter(filterId)
if f != nil {
newMail := f.Retrieve()
@ -235,14 +234,14 @@ func (api *PublicWhisperAPI) GetFilterChanges(filterId uint32) []WhisperMessage
}
// GetMessages retrieves all the known messages that match a specific filter.
func (api *PublicWhisperAPI) GetMessages(filterId uint32) []WhisperMessage {
func (api *PublicWhisperAPI) GetMessages(filterId string) []*WhisperMessage {
all := api.whisper.Messages(filterId)
return toWhisperMessages(all)
}
// toWhisperMessages converts a Whisper message to a RPC whisper message.
func toWhisperMessages(messages []*ReceivedMessage) []WhisperMessage {
msgs := make([]WhisperMessage, len(messages))
func toWhisperMessages(messages []*ReceivedMessage) []*WhisperMessage {
msgs := make([]*WhisperMessage, len(messages))
for i, msg := range messages {
msgs[i] = NewWhisperMessage(msg)
}
@ -282,8 +281,8 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
}
filter := api.whisper.GetFilter(args.FilterID)
if filter == nil && args.FilterID > 0 {
info := fmt.Sprintf("Post: wrong filter id %d", args.FilterID)
if filter == nil && len(args.FilterID) > 0 {
info := fmt.Sprintf("Post: wrong filter id %s", args.FilterID)
glog.V(logger.Error).Infof(info)
return errors.New(info)
}
@ -299,7 +298,7 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
if (params.Topic == TopicType{}) {
sz := len(filter.Topics)
if sz < 1 {
info := fmt.Sprintf("Post: no topics in filter # %d", args.FilterID)
info := fmt.Sprintf("Post: no topics in filter # %s", args.FilterID)
glog.V(logger.Error).Infof(info)
return errors.New(info)
} else if sz == 1 {
@ -374,17 +373,17 @@ type PostArgs struct {
Payload hexutil.Bytes `json:"payload"`
WorkTime uint32 `json:"worktime"`
PoW float64 `json:"pow"`
FilterID uint32 `json:"filterID"`
FilterID string `json:"filterID"`
PeerID hexutil.Bytes `json:"peerID"`
}
type WhisperFilterArgs struct {
To string
From string
KeyName string
PoW float64
Topics []TopicType
AcceptP2P bool
To string `json:"to"`
From string `json:"from"`
KeyName string `json:"keyname"`
PoW float64 `json:"pow"`
Topics []TopicType `json:"topics"`
AcceptP2P bool `json:"p2p"`
}
// UnmarshalJSON implements the json.Unmarshaler interface, invoked to convert a
@ -397,7 +396,7 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
KeyName string `json:"keyname"`
PoW float64 `json:"pow"`
Topics []interface{} `json:"topics"`
AcceptP2P bool `json:"acceptP2P"`
AcceptP2P bool `json:"p2p"`
}
if err := json.Unmarshal(b, &obj); err != nil {
return err
@ -438,6 +437,7 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
// WhisperMessage is the RPC representation of a whisper message.
type WhisperMessage struct {
Topic string `json:"topic"`
Payload string `json:"payload"`
Padding string `json:"padding"`
From string `json:"from"`
@ -449,15 +449,22 @@ type WhisperMessage struct {
}
// NewWhisperMessage converts an internal message into an API version.
func NewWhisperMessage(message *ReceivedMessage) WhisperMessage {
return WhisperMessage{
func NewWhisperMessage(message *ReceivedMessage) *WhisperMessage {
msg := WhisperMessage{
Topic: common.ToHex(message.Topic[:]),
Payload: common.ToHex(message.Payload),
Padding: common.ToHex(message.Padding),
From: common.ToHex(crypto.FromECDSAPub(message.SigToPubKey())),
To: common.ToHex(crypto.FromECDSAPub(message.Dst)),
Sent: message.Sent,
TTL: message.TTL,
PoW: message.PoW,
Hash: common.ToHex(message.EnvelopeHash.Bytes()),
}
if message.Dst != nil {
msg.To = common.ToHex(crypto.FromECDSAPub(message.Dst))
}
if isMessageSigned(message.Raw[0]) {
msg.From = common.ToHex(crypto.FromECDSAPub(message.SigToPubKey()))
}
return &msg
}

14
whisper/whisperv5/api_test.go
View File

@ -42,7 +42,7 @@ func TestBasic(t *testing.T) {
t.Fatalf("wrong version: %d.", ver)
}
mail := api.GetFilterChanges(1)
mail := api.GetFilterChanges("non-existent-id")
if len(mail) != 0 {
t.Fatalf("failed GetFilterChanges: premature result")
}
@ -152,7 +152,7 @@ func TestUnmarshalFilterArgs(t *testing.T) {
"keyname":"testname",
"pow":2.34,
"topics":["0x00000000", "0x007f80ff", "0xff807f00", "0xf26e7779"],
"acceptP2P":true
"p2p":true
}`)
var f WhisperFilterArgs
@ -212,8 +212,8 @@ func TestUnmarshalPostArgs(t *testing.T) {
"payload":"0x7061796C6F61642073686F756C642062652070736575646F72616E646F6D",
"worktime":777,
"pow":3.1416,
"filterID":64,
"peerID":"0xf26e7779"
"filterid":"test-filter-id",
"peerid":"0xf26e7779"
}`)
var a PostArgs
@ -249,15 +249,15 @@ func TestUnmarshalPostArgs(t *testing.T) {
if a.PoW != 3.1416 {
t.Fatalf("wrong pow: %f.", a.PoW)
}
if a.FilterID != 64 {
t.Fatalf("wrong FilterID: %d.", a.FilterID)
if a.FilterID != "test-filter-id" {
t.Fatalf("wrong FilterID: %s.", a.FilterID)
}
if !bytes.Equal(a.PeerID[:], a.Topic[:]) {
t.Fatalf("wrong PeerID: %x.", a.PeerID)
}
}
func waitForMessage(api *PublicWhisperAPI, id uint32, target int) bool {
func waitForMessage(api *PublicWhisperAPI, id string, target int) bool {
for i := 0; i < 64; i++ {
all := api.GetMessages(id)
if len(all) >= target {

31
whisper/whisperv5/benchmarks_test.go
View File

@ -34,7 +34,6 @@ func BenchmarkDeriveOneTimeKey(b *testing.B) {
}
}
//func TestEncryptionSym(b *testing.T) {
func BenchmarkEncryptionSym(b *testing.B) {
InitSingleTest()
@ -181,3 +180,33 @@ func BenchmarkDecryptionAsymInvalid(b *testing.B) {
}
}
}
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)
}
}
}

4
whisper/whisperv5/doc.go
View File

@ -55,8 +55,8 @@ const (
saltLength = 12
AESNonceMaxLength = 12
MaxMessageLength = 0xFFFF // todo: remove this restriction after testing. this should be regulated by PoW.
MinimumPoW = 1.0 // todo: review after testing.
MaxMessageLength = 0x0FFFFF // todo: remove this restriction after testing. this should be regulated by PoW.
MinimumPoW = 10.0 // todo: review after testing.
padSizeLimitLower = 128 // it can not be less - we don't want to reveal the absence of signature
padSizeLimitUpper = 256 // just an arbitrary number, could be changed without losing compatibility

10
whisper/whisperv5/envelope.go
View File

@ -116,12 +116,16 @@ func (e *Envelope) Seal(options *MessageParams) error {
}
if target > 0 && bestBit < target {
return errors.New("Failed to reach the PoW target")
return errors.New("Failed to reach the PoW target, insufficient work time")
}
return nil
}
func (e *Envelope) size() int {
return len(e.Data) + len(e.Version) + len(e.AESNonce) + len(e.Salt) + 20
}
func (e *Envelope) PoW() float64 {
if e.pow == 0 {
e.calculatePoW(0)
@ -137,14 +141,14 @@ func (e *Envelope) calculatePoW(diff uint32) {
h = crypto.Keccak256(buf)
firstBit := common.FirstBitSet(common.BigD(h))
x := math.Pow(2, float64(firstBit))
x /= float64(len(e.Data)) // we only count e.Data, other variable-sized members are checked in Whisper.add()
x /= float64(e.size())
x /= float64(e.TTL + diff)
e.pow = x
}
func (e *Envelope) powToFirstBit(pow float64) int {
x := pow
x *= float64(len(e.Data))
x *= float64(e.size())
x *= float64(e.TTL)
bits := math.Log2(x)
bits = math.Ceil(bits)

45
whisper/whisperv5/filter.go
View File

@ -18,6 +18,8 @@ package whisperv5
import (
"crypto/ecdsa"
crand "crypto/rand"
"fmt"
"sync"
"github.com/ethereum/go-ethereum/common"
@ -39,20 +41,41 @@ type Filter struct {
}
type Filters struct {
id uint32 // can contain any value except zero
watchers map[uint32]*Filter
watchers map[string]*Filter
whisper *Whisper
mutex sync.RWMutex
}
func NewFilters(w *Whisper) *Filters {
return &Filters{
watchers: make(map[uint32]*Filter),
watchers: make(map[string]*Filter),
whisper: w,
}
}
func (fs *Filters) Install(watcher *Filter) uint32 {
func (fs *Filters) generateRandomID() (id string, err error) {
buf := make([]byte, 20)
for i := 0; i < 3; i++ {
_, err = crand.Read(buf)
if err != nil {
continue
}
if !validateSymmetricKey(buf) {
err = fmt.Errorf("error in generateRandomID: crypto/rand failed to generate random data")
continue
}
id = common.Bytes2Hex(buf)
if fs.watchers[id] != nil {
err = fmt.Errorf("error in generateRandomID: generated same ID twice")
continue
}
return id, err
}
return "", err
}
func (fs *Filters) Install(watcher *Filter) (string, error) {
if watcher.Messages == nil {
watcher.Messages = make(map[common.Hash]*ReceivedMessage)
}
@ -60,21 +83,23 @@ func (fs *Filters) Install(watcher *Filter) uint32 {
fs.mutex.Lock()
defer fs.mutex.Unlock()
fs.id++
fs.watchers[fs.id] = watcher
return fs.id
id, err := fs.generateRandomID()
if err == nil {
fs.watchers[id] = watcher
}
return id, err
}
func (fs *Filters) Uninstall(id uint32) {
func (fs *Filters) Uninstall(id string) {
fs.mutex.Lock()
defer fs.mutex.Unlock()
delete(fs.watchers, id)
}
func (fs *Filters) Get(i uint32) *Filter {
func (fs *Filters) Get(id string) *Filter {
fs.mutex.RLock()
defer fs.mutex.RUnlock()
return fs.watchers[i]
return fs.watchers[id]
}
func (fs *Filters) NotifyWatchers(env *Envelope, p2pMessage bool) {

37
whisper/whisperv5/filter_test.go
View File

@ -43,7 +43,7 @@ func InitDebugTest(i int64) {
type FilterTestCase struct {
f *Filter
id uint32
id string
alive bool
msgCnt int
}
@ -100,14 +100,17 @@ func TestInstallFilters(t *testing.T) {
filters := NewFilters(w)
tst := generateTestCases(t, SizeTestFilters)
var j uint32
var err error
var j string
for i := 0; i < SizeTestFilters; i++ {
j = filters.Install(tst[i].f)
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 j < SizeTestFilters-1 {
t.Fatalf("seed %d: wrong index %d", seed, j)
if len(j) != 40 {
t.Fatalf("seed %d: wrong filter id size [%d]", seed, len(j))
}
}
for _, testCase := range tst {
@ -519,17 +522,25 @@ func TestWatchers(t *testing.T) {
var i int
var j uint32
var e *Envelope
var x, firstID string
var err error
w := New()
filters := NewFilters(w)
tst := generateTestCases(t, NumFilters)
for i = 0; i < NumFilters; i++ {
tst[i].f.Src = nil
j = filters.Install(tst[i].f)
tst[i].id = j
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
}
}
last := j
lastID := x
var envelopes [NumMessages]*Envelope
for i = 0; i < NumMessages; i++ {
@ -571,9 +582,9 @@ func TestWatchers(t *testing.T) {
// another round with a cloned filter
clone := cloneFilter(tst[0].f)
filters.Uninstall(last)
filters.Uninstall(lastID)
total = 0
last = NumFilters - 1
last := NumFilters - 1
tst[last].f = clone
filters.Install(clone)
for i = 0; i < NumFilters; i++ {
@ -640,7 +651,7 @@ func TestWatchers(t *testing.T) {
t.Fatalf("failed with seed %d: total: got %d, want 0.", seed, total)
}
f := filters.Get(1)
f := filters.Get(firstID)
if f == nil {
t.Fatalf("failed to get the filter with seed %d.", seed)
}

9
whisper/whisperv5/peer_test.go
View File

@ -79,7 +79,7 @@ type TestNode struct {
shh *Whisper
id *ecdsa.PrivateKey
server *p2p.Server
filerId uint32
filerId string
}
var result TestData
@ -122,7 +122,10 @@ func initialize(t *testing.T) {
topics := make([]TopicType, 0)
topics = append(topics, sharedTopic)
f := Filter{KeySym: sharedKey, Topics: topics}
node.filerId = node.shh.Watch(&f)
node.filerId, err = node.shh.Watch(&f)
if err != nil {
t.Fatalf("failed to install the filter: %s.", err)
}
node.id, err = crypto.HexToECDSA(keys[i])
if err != nil {
t.Fatalf("failed convert the key: %s.", keys[i])
@ -187,7 +190,7 @@ func checkPropagation(t *testing.T) {
for i := 0; i < NumNodes; i++ {
f := nodes[i].shh.GetFilter(nodes[i].filerId)
if f == nil {
t.Fatalf("failed to get filterId %d from node %d.", nodes[i].filerId, i)
t.Fatalf("failed to get filterId %s from node %d.", nodes[i].filerId, i)
}
mail := f.Retrieve()

8
whisper/whisperv5/whisper.go
View File

@ -272,16 +272,16 @@ func (w *Whisper) GetSymKey(name string) []byte {
// Watch installs a new message handler to run in case a matching packet arrives
// from the whisper network.
func (w *Whisper) Watch(f *Filter) uint32 {
func (w *Whisper) Watch(f *Filter) (string, error) {
return w.filters.Install(f)
}
func (w *Whisper) GetFilter(id uint32) *Filter {
func (w *Whisper) GetFilter(id string) *Filter {
return w.filters.Get(id)
}
// Unwatch removes an installed message handler.
func (w *Whisper) Unwatch(id uint32) {
func (w *Whisper) Unwatch(id string) {
w.filters.Uninstall(id)
}
@ -575,7 +575,7 @@ func (w *Whisper) Envelopes() []*Envelope {
}
// Messages retrieves all the decrypted messages matching a filter id.
func (w *Whisper) Messages(id uint32) []*ReceivedMessage {
func (w *Whisper) Messages(id string) []*ReceivedMessage {
result := make([]*ReceivedMessage, 0)
w.poolMu.RLock()
defer w.poolMu.RUnlock()

4
whisper/whisperv5/whisper_test.go
View File

@ -44,7 +44,7 @@ func TestWhisperBasic(t *testing.T) {
if uint64(w.Version()) != ProtocolVersion {
t.Fatalf("failed whisper Version: %v.", shh.Version)
}
if w.GetFilter(0) != nil {
if w.GetFilter("non-existent") != nil {
t.Fatalf("failed GetFilter.")
}
@ -69,7 +69,7 @@ func TestWhisperBasic(t *testing.T) {
if len(mail) != 0 {
t.Fatalf("failed w.Envelopes().")
}
m := w.Messages(0)
m := w.Messages("non-existent")
if len(m) != 0 {
t.Fatalf("failed w.Messages.")
}