whisper: project restructured, version 5 introduced

cmd/gethrpctest/main.go

@@ -32,7 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/tests"
-	"github.com/ethereum/go-ethereum/whisper"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisper02"
 )
 
 const defaultTestKey = "b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291"

cmd/utils/flags.go

@@ -48,7 +48,7 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/pow"
 	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/whisper"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisper02"
 	"gopkg.in/urfave/cli.v1"
 )
 

whisper/whisper02/api.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"encoding/json"

whisper/whisper02/doc.go

@@ -29,4 +29,4 @@ Whisper is a pure identity-based messaging system. Whisper provides a low-level
 or prejudiced by the low-level hardware attributes and characteristics,
 particularly the notion of singular endpoints.
 */
-package whisper
+package whisper02

whisper/whisper02/envelope.go

@@ -17,7 +17,7 @@
 // Contains the Whisper protocol Envelope element. For formal details please see
 // the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#envelopes.
 
-package whisper
+package whisper02
 
 import (
 	"crypto/ecdsa"

whisper/whisper02/envelope_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"bytes"

whisper/whisper02/filter.go

@@ -16,7 +16,7 @@
 
 // Contains the message filter for fine grained subscriptions.
 
-package whisper
+package whisper02
 
 import (
 	"crypto/ecdsa"

whisper/whisper02/filter_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"bytes"

whisper/whisper02/message.go

@@ -17,7 +17,7 @@
 // Contains the Whisper protocol Message element. For formal details please see
 // the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#messages.
 
-package whisper
+package whisper02
 
 import (
 	"crypto/ecdsa"

whisper/whisper02/message_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"bytes"

whisper/whisper02/peer.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"fmt"

whisper/whisper02/peer_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"testing"

whisper/whisper02/topic.go

@@ -17,7 +17,7 @@
 // Contains the Whisper protocol Topic element. For formal details please see
 // the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#topics.
 
-package whisper
+package whisper02
 
 import "github.com/ethereum/go-ethereum/crypto"
 

whisper/whisper02/topic_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"bytes"

whisper/whisper02/whisper.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"crypto/ecdsa"

whisper/whisper02/whisper_test.go

@@ -14,7 +14,7 @@
 // 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
+package whisper02
 
 import (
 	"testing"

whisper/whisper05/api.go

@@ -0,0 +1,338 @@
+// Copyright 2015 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 whisper05
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// PublicWhisperAPI provides the whisper RPC service.
+type PublicWhisperAPI struct {
+	whisper *Whisper
+}
+
+// NewPublicWhisperAPI create a new RPC whisper service.
+func NewPublicWhisperAPI(w *Whisper) *PublicWhisperAPI {
+	return &PublicWhisperAPI{whisper: w}
+}
+
+// Version returns the Whisper version this node offers.
+func (self *PublicWhisperAPI) Version() (*rpc.HexNumber, error) {
+	if self.whisper == nil {
+		return rpc.NewHexNumber(0), whisperOffLineErr
+	}
+	return rpc.NewHexNumber(self.whisper.Version()), nil
+}
+
+// HasIdentity checks if the the whisper node is configured with the private key
+// of the specified public pair.
+func (self *PublicWhisperAPI) HasIdentity(identity string) (bool, error) {
+	if self.whisper == nil {
+		return false, whisperOffLineErr
+	}
+	return self.whisper.HasIdentity(crypto.ToECDSAPub(common.FromHex(identity))), nil
+}
+
+// NewIdentity generates a new cryptographic identity for the client, and injects
+// it into the known identities for message decryption.
+func (self *PublicWhisperAPI) NewIdentity() (string, error) {
+	if self.whisper == nil {
+		return "", whisperOffLineErr
+	}
+	identity := self.whisper.NewIdentity()
+	return common.ToHex(crypto.FromECDSAPub(&identity.PublicKey)), nil
+}
+
+// NewWhisperFilter creates and registers a new message filter to watch for inbound whisper messages.
+func (self *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber, error) {
+	if self.whisper == nil {
+		return nil, whisperOffLineErr
+	}
+
+	filter := Filter{
+		Src:      crypto.ToECDSAPub(args.From),
+		Dst:      crypto.ToECDSAPub(args.To),
+		KeySym:   args.KeySym,
+		PoW:      args.PoW,
+		messages: make(map[common.Hash]*ReceivedMessage),
+	}
+
+	if len(args.Topics) > 0 {
+		for _, x := range args.Topics {
+			filter.Topics = append(filter.Topics, x)
+		}
+	}
+
+	// todo: add glog on error everywhere
+
+	if len(args.To) == 0 && len(args.KeySym) == 0 {
+		info := "NewFilter: filter must contain either symmetric or asymmetric key"
+		glog.V(logger.Error).Infof(info)
+		return nil, errors.New(info)
+	}
+
+	if len(args.KeySym) > 0 && len(args.Topics) == 0 {
+		return nil, fmt.Errorf("NewFilter: topic encryption require at least one topic")
+	}
+
+	if len(args.KeySym) > 0 {
+		filter.TopicKeyHash = crypto.Keccak256Hash(filter.KeySym)
+		if len(args.Topics) > 0 {
+			// if Topics are not provided, just use the default derivation function
+			t := DeriveTopicFromSymmetricKey(args.KeySym)
+			filter.Topics = append(filter.Topics, t)
+		}
+	}
+
+	if len(args.To) > 0 {
+		if !validatePublicKey(filter.Dst) {
+			return nil, fmt.Errorf("NewFilter: Invalid 'To' address")
+		}
+		filter.KeyAsym = self.whisper.GetIdentity(filter.Dst)
+		if filter.KeyAsym == nil {
+			info := "NewFilter: non-existent identity provided"
+			glog.V(logger.Error).Infof(info)
+			return nil, errors.New(info)
+		}
+	}
+
+	if len(args.From) > 0 {
+		if !validatePublicKey(filter.Src) {
+			return nil, fmt.Errorf("NewFilter: Invalid 'From' address")
+		}
+	}
+
+	id := self.whisper.Watch(&filter)
+	return rpc.NewHexNumber(id), nil
+}
+
+// UninstallFilter disables and removes an existing filter.
+func (self *PublicWhisperAPI) UninstallFilter(filterId rpc.HexNumber) {
+	self.whisper.Unwatch(filterId.Int())
+}
+
+// GetFilterChanges retrieves all the new messages matched by a filter since the last retrieval.
+func (self *PublicWhisperAPI) GetFilterChanges(filterId rpc.HexNumber) []WhisperMessage {
+	f := self.whisper.filters.Get(filterId.Int())
+	if f != nil {
+		newMail := f.retrieve()
+		return toWhisperMessages(newMail)
+	}
+	return toWhisperMessages(nil)
+}
+
+// GetMessages retrieves all the known messages that match a specific filter.
+func (self *PublicWhisperAPI) GetMessages(filterId rpc.HexNumber) []WhisperMessage {
+	all := self.whisper.Messages(filterId.Int())
+	return toWhisperMessages(all)
+}
+
+// toWhisperMessages converts a Whisper message to a RPC whisper message.
+func toWhisperMessages(messages []*ReceivedMessage) []WhisperMessage {
+	msgs := make([]WhisperMessage, len(messages))
+	for i, msg := range messages {
+		msgs[i] = NewWhisperMessage(msg)
+	}
+	return msgs
+}
+
+// Post injects a message into the whisper network for distribution.
+func (self *PublicWhisperAPI) Post(args PostArgs) error {
+	if self.whisper == nil {
+		return whisperOffLineErr
+	}
+
+	message := NewSentMessage(args.Payload)
+	options := Options{
+		TTL:      args.TTL,
+		Dst:      crypto.ToECDSAPub(args.To),
+		KeySym:   args.KeySym,
+		Topic:    args.Topic,
+		Pading:   args.Padding,
+		WorkTime: args.WorkTime,
+		PoW:      args.PoW,
+	}
+
+	// todo: add glog on error everywhere
+
+	if len(args.KeySym) > 0 && (args.Topic == TopicType{}) {
+		// if Topic is not provided, just use the default derivation function
+		options.Topic = DeriveTopicFromSymmetricKey(args.KeySym)
+	}
+
+	if len(args.From) > 0 {
+		pub := crypto.ToECDSAPub(args.From)
+		if !validatePublicKey(pub) {
+			return fmt.Errorf("Post: Invalid 'From' address")
+		}
+		options.Src = self.whisper.GetIdentity(pub)
+		if options.Src == nil {
+			info := "Post: non-existent identity provided"
+			glog.V(logger.Error).Infof(info)
+			return errors.New(info)
+		}
+	}
+
+	if len(args.To) == 0 && len(args.KeySym) == 0 {
+		info := "Post: message must be encrypted either symmetrically or asymmetrically"
+		glog.V(logger.Error).Infof(info)
+		return errors.New(info)
+	}
+
+	if len(args.To) > 0 {
+		if !validatePublicKey(options.Dst) {
+			return fmt.Errorf("Post: Invalid 'To' address")
+		}
+	}
+
+	envelope, err := message.Wrap(options)
+	if err != nil {
+		return err
+	}
+	return self.whisper.Send(envelope)
+}
+
+type PostArgs struct {
+	TTL      uint32       `json:"ttl"`
+	From     rpc.HexBytes `json:"from"`
+	To       rpc.HexBytes `json:"to"`
+	KeySym   rpc.HexBytes `json:"key"`
+	Topic    TopicType    `json:"topic"`
+	Padding  rpc.HexBytes `json:"padding"`
+	Payload  rpc.HexBytes `json:"payload"`
+	WorkTime uint32       `json:"worktime"`
+	PoW      float64      `json:"pow"`
+}
+
+func (args *PostArgs) UnmarshalJSON(data []byte) (err error) {
+	var obj struct {
+		TTL      uint32       `json:"ttl"`
+		From     rpc.HexBytes `json:"from"`
+		To       rpc.HexBytes `json:"to"`
+		Key      rpc.HexBytes `json:"key"`
+		Topic    TopicType    `json:"topic"`
+		Payload  rpc.HexBytes `json:"payload"`
+		Padding  rpc.HexBytes `json:"padding"`
+		WorkTime uint32       `json:"worktime"`
+		PoW      float64      `json:"pow"`
+	}
+
+	if err := json.Unmarshal(data, &obj); err != nil {
+		return err
+	}
+
+	args.TTL = obj.TTL
+	args.From = obj.From
+	args.To = obj.To
+	args.KeySym = obj.Key
+	args.Topic = obj.Topic
+	args.Payload = obj.Payload
+	args.Padding = obj.Padding
+	args.WorkTime = obj.WorkTime
+	args.PoW = obj.PoW
+
+	return nil
+}
+
+type WhisperFilterArgs struct {
+	To     []byte
+	From   []byte
+	KeySym []byte
+	PoW    float64
+	Topics []TopicType
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface, invoked to convert a
+// JSON message blob into a WhisperFilterArgs structure.
+func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
+	// Unmarshal the JSON message and sanity check
+	var obj struct {
+		To     rpc.HexBytes  `json:"to"`
+		From   rpc.HexBytes  `json:"from"`
+		Key    rpc.HexBytes  `json:"key"`
+		PoW    float64       `json:"pow"`
+		Topics []interface{} `json:"topics"`
+	}
+	if err := json.Unmarshal(b, &obj); err != nil {
+		return err
+	}
+
+	args.To = obj.To
+	args.From = obj.From
+	args.KeySym = obj.Key
+	args.PoW = obj.PoW
+
+	// Construct the topic array
+	if obj.Topics != nil {
+		topics := make([]string, len(obj.Topics))
+		for i, field := range obj.Topics {
+			switch value := field.(type) {
+			case string:
+				topics[i] = value
+			case nil:
+				return fmt.Errorf("topic[%d] is empty", i)
+			default:
+				return fmt.Errorf("topic[%d] is not a string", i)
+			}
+		}
+		topicsDecoded := make([]TopicType, len(topics))
+		for j, s := range topics {
+			x := common.FromHex(s)
+			if x == nil || len(x) != topicLength {
+				return fmt.Errorf("topic[%d] is invalid", j)
+			}
+			topicsDecoded[j] = BytesToTopic(x)
+		}
+		args.Topics = topicsDecoded
+	}
+
+	return nil
+}
+
+// WhisperMessage is the RPC representation of a whisper message.
+type WhisperMessage struct {
+	Payload string  `json:"payload"`
+	Padding string  `json:"padding"`
+	From    string  `json:"from"`
+	To      string  `json:"to"`
+	Sent    uint32  `json:"sent"`
+	TTL     uint32  `json:"ttl"`
+	PoW     float64 `json:"pow"`
+	Hash    string  `json:"hash"`
+}
+
+// NewWhisperMessage converts an internal message into an API version.
+func NewWhisperMessage(message *ReceivedMessage) WhisperMessage {
+	return WhisperMessage{
+		Payload: common.ToHex(message.Payload),
+		Padding: common.ToHex(message.Padding),
+		From:    common.ToHex(crypto.FromECDSAPub(message.Recover())),
+		To:      common.ToHex(crypto.FromECDSAPub(message.Dst)),
+		Sent:    message.Sent,
+		TTL:     message.TTL,
+		PoW:     message.PoW,
+		Hash:    common.ToHex(message.EnvelopeHash.Bytes()),
+	}
+}

whisper/whisper05/doc.go

@@ -0,0 +1,69 @@
+// Copyright 2014 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 PoC-1.
+
+(https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec)
+
+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.
+*/
+package whisper05
+
+import (
+	"time"
+)
+
+const (
+	statusCode   = 0x00
+	messagesCode = 0x01
+
+	protocolVersion    uint64 = 5
+	protocolVersionStr        = "5.0"
+	protocolName              = "shh"
+
+	signatureFlag = byte(1 << 7)
+	paddingFlag   = byte(1 << 6)
+
+	topicLength     = 4
+	signatureLength = 65
+	maxPadLength    = 255
+	aesKeyLength    = 32
+	saltLength      = 12
+	kdfIterations   = 4096
+	msgMaxLength    = 0xFFFF
+
+	expirationCycle   = 800 * time.Millisecond
+	transmissionCycle = 300 * time.Millisecond
+
+	DefaultTTL = 50 // seconds
+)
+
+type whisperOfflineError struct{}
+
+var whisperOffLineErr = new(whisperOfflineError)
+
+func (e *whisperOfflineError) Error() string {
+	return "whisper is offline"
+}

whisper/whisper05/envelope.go

@@ -0,0 +1,207 @@
+// Copyright 2014 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. For formal details please see
+// the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#envelopes.
+
+package whisper05
+
+import (
+	"crypto/ecdsa"
+	"encoding/binary"
+	"fmt"
+	"time"
+
+	"math"
+
+	"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
+	Salt     []byte
+	AESNonce []byte
+	Data     []byte
+	EnvNonce uint64
+
+	hash common.Hash // Cached hash of the envelope to avoid rehashing every time
+	pow  float64     // Message-specific PoW as described in the Whisper specification
+}
+
+// NewEnvelope wraps a Whisper message with expiration and destination data
+// included into an envelope for network forwarding.
+func NewEnvelope(ttl uint32, topic TopicType, salt []byte, aesNonce []byte, msg *SentMessage) *Envelope {
+	return &Envelope{
+		Expiry:   uint32(time.Now().Add(time.Second * time.Duration(ttl)).Unix()),
+		TTL:      ttl,
+		Topic:    topic,
+		Salt:     salt,
+		AESNonce: aesNonce,
+		Data:     msg.Raw,
+		EnvNonce: 0,
+	}
+}
+
+func (self *Envelope) isSymmetric() bool {
+	return self.AESNonce != nil
+}
+
+func (self *Envelope) isAsymmetric() bool {
+	return !self.isSymmetric()
+}
+
+// Seal closes the envelope by spending the requested amount of time as a proof
+// of work on hashing the data.
+func (self *Envelope) Seal(options Options) {
+	var target int
+	if options.PoW == 0 {
+		// adjust for the duration of Seal() execution only if execution time is predefined unconditionally
+		self.Expiry += options.WorkTime
+	} else {
+		target = self.powToFirstBit(options.PoW)
+	}
+
+	buf := make([]byte, 64)
+	h := crypto.Keccak256(self.rlpWithoutNonce())
+	copy(buf[:32], h)
+
+	finish, bestBit := time.Now().Add(time.Duration(options.WorkTime)*time.Second).UnixNano(), 0
+	for nonce := uint64(0); time.Now().UnixNano() < finish; {
+		for i := 0; i < 1024; i++ {
+			binary.BigEndian.PutUint64(buf[56:], nonce)
+			h = crypto.Keccak256(buf)
+			firstBit := common.FirstBitSet(common.BigD(h))
+			if firstBit > bestBit {
+				self.EnvNonce, bestBit = nonce, firstBit
+				if target > 0 && bestBit >= target {
+					return
+				}
+			}
+			nonce++
+		}
+	}
+}
+
+func (self *Envelope) calculatePoW() float64 {
+	h := self.Hash()
+	firstBit := common.FirstBitSet(common.BigD(h.Bytes()))
+	x := math.Pow(2, float64(firstBit))
+	x /= float64(len(self.Data))
+	x /= float64(self.TTL)
+	return x
+}
+
+func (self *Envelope) powToFirstBit(pow float64) int {
+	x := pow
+	x *= float64(len(self.Data))
+	x *= float64(self.TTL)
+	bits := math.Log2(x)
+	bits = math.Ceil(bits)
+	return int(bits)
+}
+
+// rlpWithoutNonce returns the RLP encoded envelope contents, except the nonce.
+func (self *Envelope) rlpWithoutNonce() []byte {
+	enc, _ := rlp.EncodeToBytes([]interface{}{self.Expiry, self.TTL, self.Topic, self.Salt, self.AESNonce, self.Data})
+	return enc
+}
+
+// Hash returns the SHA3 hash of the envelope, calculating it if not yet done.
+func (self *Envelope) Hash() common.Hash {
+	if (self.hash == common.Hash{}) {
+		enc, _ := rlp.EncodeToBytes(self)
+		self.hash = crypto.Keccak256Hash(enc)
+	}
+	return self.hash
+}
+
+// DecodeRLP decodes an Envelope from an RLP data stream.
+func (self *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)(self)); err != nil {
+		return err
+	}
+	self.hash = crypto.Keccak256Hash(raw)
+	return nil
+}
+
+// OpenAsymmetric tries to decrypt an envelope, potentially encrypted with a particular key.
+func (self *Envelope) OpenAsymmetric(key *ecdsa.PrivateKey) (*ReceivedMessage, error) {
+	message := &ReceivedMessage{Raw: self.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 (self *Envelope) OpenSymmetric(key []byte) (msg *ReceivedMessage, err error) {
+	msg = &ReceivedMessage{Raw: self.Data}
+	err = msg.decryptSymmetric(key, self.Salt, self.AESNonce)
+	if err != nil {
+		msg = nil
+	}
+	return
+}
+
+// Open tries to decrypt an envelope, and populates the message fields in case of success.
+func (self *Envelope) Open(watcher *Filter) (msg *ReceivedMessage) {
+	if self.isAsymmetric() {
+		msg, _ = self.OpenAsymmetric(watcher.KeyAsym)
+		if msg != nil {
+			msg.Dst = watcher.Dst
+		}
+	} else if self.isSymmetric() {
+		msg, _ = self.OpenSymmetric(watcher.KeySym)
+		if msg != nil {
+			msg.TopicKeyHash = crypto.Keccak256Hash(watcher.KeySym)
+		}
+	}
+
+	if msg != nil {
+		ok := msg.Validate()
+		if !ok {
+			return nil
+		}
+		msg.Topic = self.Topic
+		msg.PoW = self.pow
+		msg.TTL = self.TTL
+		msg.Sent = self.Expiry - self.TTL
+		msg.EnvelopeHash = self.hash
+	}
+	return msg
+}

whisper/whisper05/filter.go

@@ -0,0 +1,193 @@
+package whisper05
+
+import (
+	"crypto/ecdsa"
+
+	"sync"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type Filter struct {
+	Src          *ecdsa.PublicKey  // Sender of the message
+	Dst          *ecdsa.PublicKey  // Recipient of the message
+	KeyAsym      *ecdsa.PrivateKey // Private Key of recipient
+	Topics       []TopicType       // Topics to filter messages with
+	KeySym       []byte            // Key associated with the Topic
+	TopicKeyHash common.Hash       // The Keccak256Hash of the symmetric key
+	PoW          float64           // Proof of work as described in the Whisper spec
+
+	messages map[common.Hash]*ReceivedMessage
+	mutex    sync.RWMutex
+}
+
+type Filters struct {
+	id       int
+	watchers map[int]*Filter
+	ch       chan Envelope
+	quit     chan struct{}
+	whisper  *Whisper
+}
+
+func NewFilters(w *Whisper) *Filters {
+	return &Filters{
+		ch:       make(chan Envelope),
+		watchers: make(map[int]*Filter),
+		quit:     make(chan struct{}),
+		whisper:  w,
+	}
+}
+
+func (self *Filters) Start() {
+	go self.loop()
+}
+
+func (self *Filters) Stop() {
+	close(self.quit)
+}
+
+func (self *Filters) Notify(env *Envelope) {
+	self.ch <- *env
+}
+
+func (self *Filters) Install(watcher *Filter) int {
+	self.watchers[self.id] = watcher
+	ret := self.id
+	self.id++
+	return ret
+}
+
+func (self *Filters) Uninstall(id int) {
+	delete(self.watchers, id)
+}
+
+func (self *Filters) Get(i int) *Filter {
+	return self.watchers[i]
+}
+
+func (self *Filters) loop() {
+	for {
+		select {
+		case <-self.quit:
+			return
+		case envelope := <-self.ch:
+			self.processEnvelope(&envelope)
+		}
+	}
+}
+
+func (self *Filters) processEnvelope(envelope *Envelope) {
+	var msg *ReceivedMessage
+	for _, watcher := range self.watchers {
+		match := false
+		if msg != nil {
+			match = watcher.MatchMessage(msg)
+		} else {
+			match = watcher.MatchEnvelope(envelope)
+			if match {
+				msg = envelope.Open(watcher)
+			}
+		}
+
+		if match && msg != nil {
+			watcher.Trigger(msg)
+		}
+	}
+
+	if msg != nil {
+		go self.whisper.addDecryptedMessage(msg)
+	}
+}
+
+func (self *Filter) expectsAsymmetricEncryption() bool {
+	return self.KeyAsym != nil
+}
+
+func (self *Filter) expectsSymmetricEncryption() bool {
+	return self.KeySym != nil
+}
+
+func (self *Filter) Trigger(msg *ReceivedMessage) {
+	self.mutex.Lock()
+	defer self.mutex.Unlock()
+
+	if _, exist := self.messages[msg.EnvelopeHash]; !exist {
+		self.messages[msg.EnvelopeHash] = msg
+	}
+}
+
+func (self *Filter) retrieve() (all []*ReceivedMessage) {
+	self.mutex.RLock()
+	defer self.mutex.RUnlock()
+
+	all = make([]*ReceivedMessage, 0, len(self.messages))
+	for _, msg := range self.messages {
+		all = append(all, msg)
+	}
+	self.messages = make(map[common.Hash]*ReceivedMessage) // delete old messages
+	return all
+}
+
+func (self *Filter) MatchMessage(msg *ReceivedMessage) bool {
+	if self.PoW > 0 && msg.PoW < self.PoW {
+		return false
+	}
+
+	if self.Src != nil && !isEqual(msg.Src, self.Src) {
+		return false
+	}
+
+	if self.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() {
+		// if Dst match, ignore the topic
+		return isEqual(self.Dst, msg.Dst)
+	} else if self.expectsSymmetricEncryption() && msg.isSymmetricEncryption() {
+		// we need to compare the keys (or rather thier hashes), because of
+		// possible collision (different keys can produce the same topic).
+		// we also need to compare the topics, because they could be arbitrary (not related to KeySym).
+		if self.TopicKeyHash == msg.TopicKeyHash {
+			for _, t := range self.Topics {
+				if t == msg.Topic {
+					return true
+				}
+			}
+			return false
+		}
+	}
+	return false
+}
+
+func (self *Filter) MatchEnvelope(envelope *Envelope) bool {
+	if self.PoW > 0 && envelope.pow < self.PoW {
+		return false
+	}
+
+	encryptionMethodMatch := false
+	if self.expectsAsymmetricEncryption() && envelope.isAsymmetric() {
+		encryptionMethodMatch = true
+		if self.Topics == nil {
+			return true // wildcard
+		}
+	} else if self.expectsSymmetricEncryption() && envelope.isSymmetric() {
+		encryptionMethodMatch = true
+	}
+
+	if encryptionMethodMatch {
+		for _, t := range self.Topics {
+			if t == envelope.Topic {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func isEqual(a, b *ecdsa.PublicKey) bool {
+	if !validatePublicKey(a) {
+		return false
+	} else if !validatePublicKey(b) {
+		return false
+	}
+	// the Curve is always the same, just compare the points
+	return a.X.Cmp(b.X) == 0 && a.Y.Cmp(b.Y) == 0
+}

whisper/whisper05/message.go

@@ -0,0 +1,339 @@
+// Copyright 2014 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. For formal details please see
+// the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#messages.
+// todo: fix the spec link, and move it to doc.go
+
+package whisper05
+
+import (
+	crand "crypto/rand"
+	"errors"
+
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/ecdsa"
+	"crypto/sha256"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"golang.org/x/crypto/pbkdf2"
+)
+
+// Options specifies the exact way a message should be wrapped into an Envelope.
+type Options struct {
+	TTL      uint32
+	Src      *ecdsa.PrivateKey
+	Dst      *ecdsa.PublicKey
+	KeySym   []byte
+	Topic    TopicType
+	Pading   []byte
+	WorkTime uint32
+	PoW      float64
+}
+
+// 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.
+type ReceivedMessage struct {
+	Raw []byte
+
+	Payload   []byte
+	Padding   []byte
+	Signature []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
+	TopicKeyHash common.Hash // The Keccak256Hash of the key, associated with the Topic
+	EnvelopeHash common.Hash // Message envelope hash to act as a unique id
+}
+
+func DeriveTopicFromSymmetricKey(key []byte) TopicType {
+	// todo: it is not secure enough, use kdf instead
+	hash := crypto.Keccak256Hash(key)
+	return HashToTopic(hash)
+}
+
+func isMessageSigned(flags byte) bool {
+	return (flags & signatureFlag) != 0
+}
+
+func isMessagePadded(flags byte) bool {
+	return (flags & paddingFlag) != 0
+}
+
+func (self *ReceivedMessage) isSymmetricEncryption() bool {
+	return self.TopicKeyHash != common.Hash{}
+}
+
+func (self *ReceivedMessage) isAsymmetricEncryption() bool {
+	return self.Dst != nil
+}
+
+// NewMessage creates and initializes a non-signed, non-encrypted Whisper message.
+func NewSentMessage(payload []byte) *SentMessage {
+	// Construct an initial flag set: no signature, no padding, other bits random
+	buf := make([]byte, 1)
+	crand.Read(buf)
+	flags := buf[0]
+	flags &= ^signatureFlag
+	flags &= ^paddingFlag
+
+	msg := SentMessage{}
+	msg.Raw = make([]byte, 1, len(payload)+signatureLength+maxPadLength+1)
+	msg.Raw[0] = flags
+	msg.Raw = append(msg.Raw, payload...)
+	return &msg
+}
+
+// appendPadding appends the pseudorandom padding bytes and sets the padding flag.
+// The last byte contains the size of padding (thus, its size must not exceed 256).
+func (self *SentMessage) appendPadding(options Options) {
+	if isMessageSigned(self.Raw[0]) {
+		// this should not happen, but no reason to panic
+		glog.V(logger.Error).Infof("Trying to pad a message which was already signed")
+		return
+	} else if isMessagePadded(self.Raw[0]) {
+		// this should not happen, but no reason to panic
+		glog.V(logger.Error).Infof("Trying to pad a message which was already padded")
+		return
+	}
+
+	total := len(self.Raw)
+	if options.Src != nil {
+		total += signatureLength
+	}
+	odd := total % maxPadLength
+	if odd > 0 {
+		padSize := maxPadLength - odd
+		buf := make([]byte, padSize)
+		crand.Read(buf)
+		if options.Pading != nil {
+			copy(buf, options.Pading)
+		}
+		buf[padSize-1] = byte(padSize)
+		self.Raw = append(self.Raw, buf...)
+		self.Raw[0] |= paddingFlag
+	}
+}
+
+// sign calculates and sets the cryptographic signature for the message,
+// also setting the sign flag.
+func (self *SentMessage) sign(key *ecdsa.PrivateKey) (err error) {
+	if isMessageSigned(self.Raw[0]) {
+		// this should not happen, but no reason to panic
+		glog.V(logger.Error).Infof("Trying to sign a message which was already signed")
+		return
+	}
+	hash := crypto.Keccak256(self.Raw)
+	signature, err := crypto.Sign(hash, key)
+	if err != nil {
+		self.Raw = append(self.Raw, signature...)
+		self.Raw[0] |= signatureFlag
+	}
+	return
+}
+
+// encryptAsymmetric encrypts a message with a public key.
+func (self *SentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error {
+	encrypted, err := crypto.Encrypt(key, self.Raw)
+	if err == nil {
+		self.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 (self *SentMessage) encryptSymmetric(key []byte) (salt []byte, nonce []byte, err error) {
+	salt = make([]byte, saltLength)
+	_, err = crand.Read(salt)
+	if err != nil {
+		return
+	}
+
+	derivedKey := pbkdf2.Key(key, salt, kdfIterations, aesKeyLength, sha256.New)
+
+	block, err := aes.NewCipher(derivedKey)
+	if err != nil {
+		return
+	}
+	aesgcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return
+	}
+
+	// never use more than 2^32 random nonces with a given key
+	nonce = make([]byte, aesgcm.NonceSize())
+	_, err = crand.Read(nonce)
+	if err != nil {
+		return
+	}
+	self.Raw = aesgcm.Seal(nil, nonce, self.Raw, nil)
+	return
+}
+
+// Wrap bundles the message into an Envelope to transmit over the network.
+//
+// pow (Proof Of Work) controls how much time to spend on hashing the message,
+// inherently controlling its priority through the network (smaller hash, bigger
+// priority).
+//
+// The user can control the amount of identity, privacy and encryption through
+// the options parameter as follows:
+//   - options.From == nil && options.To == nil: anonymous broadcast
+//   - options.From != nil && options.To == nil: signed broadcast (known sender)
+//   - options.From == nil && options.To != nil: encrypted anonymous message
+//   - options.From != nil && options.To != nil: encrypted signed message
+func (self *SentMessage) Wrap(options Options) (envelope *Envelope, err error) {
+	if options.TTL == 0 {
+		options.TTL = DefaultTTL
+	}
+	self.appendPadding(options)
+	if options.Src != nil {
+		if err = self.sign(options.Src); err != nil {
+			return
+		}
+	}
+	if len(self.Raw) > msgMaxLength {
+		glog.V(logger.Error).Infof("Message size must not exceed %d bytes", msgMaxLength)
+		err = errors.New("Oversized message")
+		return
+	}
+	var salt, nonce []byte
+	if options.Dst != nil {
+		err = self.encryptAsymmetric(options.Dst)
+	} else if options.KeySym != nil {
+		salt, nonce, err = self.encryptSymmetric(options.KeySym)
+	} else {
+		err = errors.New("Unable to encrypt the message: neither Dst nor Key")
+	}
+
+	if err == nil {
+		if (options.Topic == TopicType{}) {
+			options.Topic = DeriveTopicFromSymmetricKey(options.KeySym)
+		}
+
+		envelope = NewEnvelope(options.TTL, options.Topic, salt, nonce, self)
+		envelope.Seal(options)
+	}
+	return
+}
+
+// decryptSymmetric decrypts a message with a topic key, using AES-GCM-256.
+// nonce size should be 12 bytes (see cipher.gcmStandardNonceSize).
+func (self *ReceivedMessage) decryptSymmetric(key []byte, salt []byte, nonce []byte) error {
+	derivedKey := pbkdf2.Key(key, salt, kdfIterations, aesKeyLength, sha256.New)
+
+	block, err := aes.NewCipher(derivedKey)
+	if err != nil {
+		return err
+	}
+	aesgcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return err
+	}
+	if len(nonce) != aesgcm.NonceSize() {
+		glog.V(logger.Error).Infof("AES nonce size must be %d bytes", aesgcm.NonceSize())
+		return errors.New("Wrong AES nonce size")
+	}
+	decrypted, err := aesgcm.Open(nil, nonce, self.Raw, nil)
+	if err != nil {
+		return err
+	}
+	self.Raw = decrypted
+	return nil
+}
+
+// decryptAsymmetric decrypts an encrypted payload with a private key.
+func (self *ReceivedMessage) decryptAsymmetric(key *ecdsa.PrivateKey) error {
+	decrypted, err := crypto.Decrypt(key, self.Raw)
+	if err == nil {
+		self.Raw = decrypted
+	}
+	return err
+}
+
+// Validate checks the validity and extracts the fields in case of success
+func (self *ReceivedMessage) Validate() bool {
+	sz := len(self.Raw)
+	cur := sz
+	if sz < 1 {
+		return false
+	}
+
+	if isMessageSigned(self.Raw[0]) {
+		cur -= signatureLength
+		if cur <= 1 {
+			return false
+		}
+		self.Signature = self.Raw[cur:]
+		self.Src = self.Recover()
+		if self.Src == nil {
+			return false
+		}
+	}
+
+	if isMessagePadded(self.Raw[0]) {
+		paddingSize := int(self.Raw[cur-1])
+		beg := cur - paddingSize
+		if beg <= 1 {
+			return false
+		}
+		self.Padding = self.Raw[beg : cur-1]
+		cur = beg
+	}
+
+	self.Payload = self.Raw[1:cur]
+	if self.isSymmetricEncryption() == self.isAsymmetricEncryption() {
+		return false
+	}
+	return true
+}
+
+// Recover retrieves the public key of the message signer.
+func (self *ReceivedMessage) Recover() *ecdsa.PublicKey {
+	defer func() { recover() }() // in case of invalid signature
+
+	pub, err := crypto.SigToPub(self.hash(), self.Signature)
+	if err != nil {
+		glog.V(logger.Error).Infof("Could not get public key from signature: %v", err)
+		return nil
+	}
+	return pub
+}
+
+// hash calculates the SHA3 checksum of the message flags, payload and padding.
+func (self *ReceivedMessage) hash() []byte {
+	if isMessageSigned(self.Raw[0]) {
+		sz := len(self.Raw) - signatureLength
+		return crypto.Keccak256(self.Raw[:sz])
+	}
+	return crypto.Keccak256(self.Raw)
+}

whisper/whisper05/peer.go

@@ -0,0 +1,175 @@
+// Copyright 2014 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 whisper05
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/rlp"
+	set "gopkg.in/fatih/set.v0"
+)
+
+// peer represents a whisper protocol peer connection.
+type peer struct {
+	host *Whisper
+	peer *p2p.Peer
+	ws   p2p.MsgReadWriter
+
+	known *set.Set // Messages already known by the peer to avoid wasting bandwidth
+
+	quit chan struct{}
+}
+
+// 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,
+		known: set.New(),
+		quit:  make(chan struct{}),
+	}
+}
+
+// start initiates the peer updater, periodically broadcasting the whisper packets
+// into the network.
+func (self *peer) start() {
+	go self.update()
+	glog.V(logger.Debug).Infof("%v: whisper started", self.peer)
+}
+
+// stop terminates the peer updater, stopping message forwarding to it.
+func (self *peer) stop() {
+	close(self.quit)
+	glog.V(logger.Debug).Infof("%v: whisper stopped", self.peer)
+}
+
+// handshake sends the protocol initiation status message to the remote peer and
+// verifies the remote status too.
+func (self *peer) handshake() error {
+	// Send the handshake status message asynchronously
+	errc := make(chan error, 1)
+	go func() {
+		errc <- p2p.SendItems(self.ws, statusCode, protocolVersion)
+	}()
+	// Fetch the remote status packet and verify protocol match
+	packet, err := self.ws.ReadMsg()
+	if err != nil {
+		return err
+	}
+	if packet.Code != statusCode {
+		return fmt.Errorf("peer sent %x before status packet", packet.Code)
+	}
+	s := rlp.NewStream(packet.Payload, uint64(packet.Size))
+	if _, err := s.List(); err != nil {
+		return fmt.Errorf("bad status message: %v", err)
+	}
+	peerVersion, err := s.Uint()
+	if err != nil {
+		return fmt.Errorf("bad status message: %v", err)
+	}
+	if peerVersion != protocolVersion {
+		return fmt.Errorf("protocol version mismatch %d != %d", peerVersion, protocolVersion)
+	}
+	// Wait until out own status is consumed too
+	if err := <-errc; err != nil {
+		return fmt.Errorf("failed to send status packet: %v", err)
+	}
+	return nil
+}
+
+// update executes periodic operations on the peer, including message transmission
+// and expiration.
+func (self *peer) update() {
+	// Start the tickers for the updates
+	expire := time.NewTicker(expirationCycle)
+	transmit := time.NewTicker(transmissionCycle)
+
+	// Loop and transmit until termination is requested
+	for {
+		select {
+		case <-expire.C:
+			self.expire()
+
+		case <-transmit.C:
+			if err := self.broadcast(); err != nil {
+				glog.V(logger.Info).Infof("%v: broadcast failed: %v", self.peer, err)
+				return
+			}
+
+		case <-self.quit:
+			return
+		}
+	}
+}
+
+// mark marks an envelope known to the peer so that it won't be sent back.
+func (self *peer) mark(envelope *Envelope) {
+	self.known.Add(envelope.Hash())
+}
+
+// marked checks if an envelope is already known to the remote peer.
+func (self *peer) marked(envelope *Envelope) bool {
+	return self.known.Has(envelope.Hash())
+}
+
+// expire iterates over all the known envelopes in the host and removes all
+// expired (unknown) ones from the known list.
+func (self *peer) expire() {
+	// Assemble the list of available envelopes
+	available := set.NewNonTS()
+	for _, envelope := range self.host.Envelopes() {
+		available.Add(envelope.Hash())
+	}
+	// Cross reference availability with known status
+	unmark := make(map[common.Hash]struct{})
+	self.known.Each(func(v interface{}) bool {
+		if !available.Has(v.(common.Hash)) {
+			unmark[v.(common.Hash)] = struct{}{}
+		}
+		return true
+	})
+	// Dump all known but unavailable
+	for hash, _ := range unmark {
+		self.known.Remove(hash)
+	}
+}
+
+// broadcast iterates over the collection of envelopes and transmits yet unknown
+// ones over the network.
+func (self *peer) broadcast() error {
+	// Fetch the envelopes and collect the unknown ones
+	envelopes := self.host.Envelopes()
+	transmit := make([]*Envelope, 0, len(envelopes))
+	for _, envelope := range envelopes {
+		if !self.marked(envelope) {
+			transmit = append(transmit, envelope)
+			self.mark(envelope)
+		}
+	}
+	// Transmit the unknown batch (potentially empty)
+	if err := p2p.Send(self.ws, messagesCode, transmit); err != nil {
+		return err
+	}
+	glog.V(logger.Detail).Infoln(self.peer, "broadcasted", len(transmit), "message(s)")
+	return nil
+}

whisper/whisper05/topic.go

@@ -0,0 +1,92 @@
+// Copyright 2015 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. For formal details please see
+// the specs at https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec#topics.
+
+package whisper05
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// Topic 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
+
+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
+}
+
+func HashToTopic(h common.Hash) (t TopicType) {
+	for i := 0; i < topicLength; i++ {
+		t[i] = h[i]
+	}
+	return t
+}
+
+func NewTopic(data []byte) TopicType {
+	if data == nil {
+		return TopicType{}
+	}
+	prefix := [topicLength]byte{}
+	copy(prefix[:], crypto.Keccak256(data)[:topicLength])
+	return TopicType(prefix)
+}
+
+// NewTopicFromString creates a topic using the binary data contents of the specified string.
+func NewTopicFromString(data string) TopicType {
+	return NewTopic(common.FromHex(data))
+}
+
+// String converts a topic byte array to a string representation.
+func (self *TopicType) String() string {
+	return string(common.ToHex(self[:]))
+}
+
+// UnmarshalJSON parses a hex representation to a topic.
+func (t *TopicType) UnmarshalJSON(input []byte) error {
+	length := len(input)
+	if length >= 2 && input[0] == '"' && input[length-1] == '"' {
+		input = input[1 : length-1]
+	}
+	// strip "0x" for length check
+	if len(input) > 1 && strings.ToLower(string(input[:2])) == "0x" {
+		input = input[2:]
+	}
+	// validate the length of the input
+	if len(input) != topicLength*2 {
+		return fmt.Errorf("whisper: unmarshalJSON failed: topic must be exactly %d bytes", topicLength)
+	}
+	b := common.FromHex(string(input))
+	if b == nil {
+		return fmt.Errorf("whisper: unmarshalJSON failed: wrong topic format")
+	}
+	*t = BytesToTopic(b)
+	return nil
+}

whisper/whisper05/whisper.go

@@ -0,0 +1,333 @@
+// Copyright 2014 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 whisper05
+
+import (
+	"crypto/ecdsa"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/rpc"
+
+	"fmt"
+
+	set "gopkg.in/fatih/set.v0"
+)
+
+// Whisper represents a dark communication interface through the Ethereum
+// network, using its very own P2P communication layer.
+type Whisper struct {
+	protocol p2p.Protocol
+	filters  *Filters
+
+	privateKeys map[string]*ecdsa.PrivateKey
+	//topicKeys   map[TopicType][]byte // todo: move to the filter. this is not suitable because of possible collisions
+
+	envelopes   map[common.Hash]*Envelope        // Pool of messages currently tracked by this node
+	messages    map[common.Hash]*ReceivedMessage // Pool of successfully decrypted messages
+	expirations map[uint32]*set.SetNonTS         // Message expiration pool (TODO: something lighter)
+	poolMu      sync.RWMutex                     // Mutex to sync the message and expiration pools
+
+	peers  map[*peer]struct{} // Set of currently active peers
+	peerMu sync.RWMutex       // Mutex to sync the active peer set
+
+	quit chan struct{}
+}
+
+// New creates a Whisper client ready to communicate through the Ethereum P2P network.
+func New() *Whisper {
+	whisper := &Whisper{
+		//filters:     NewFilters(),
+		privateKeys: make(map[string]*ecdsa.PrivateKey),
+		//topicKeys:   make(map[TopicType][]byte),
+		envelopes:   make(map[common.Hash]*Envelope),
+		messages:    make(map[common.Hash]*ReceivedMessage),
+		expirations: make(map[uint32]*set.SetNonTS),
+		peers:       make(map[*peer]struct{}),
+		quit:        make(chan struct{}),
+	}
+	whisper.filters = NewFilters(whisper)
+	whisper.filters.Start()
+
+	// p2p whisper sub protocol handler
+	whisper.protocol = p2p.Protocol{
+		Name:    protocolName,
+		Version: uint(protocolVersion),
+		Length:  2,
+		Run:     whisper.handlePeer,
+	}
+
+	return whisper
+}
+
+// APIs returns the RPC descriptors the Whisper implementation offers
+func (s *Whisper) APIs() []rpc.API {
+	return []rpc.API{
+		{
+			Namespace: protocolName,
+			Version:   protocolVersionStr,
+			Service:   NewPublicWhisperAPI(s),
+			Public:    true,
+		},
+	}
+}
+
+// Protocols returns the whisper sub-protocols ran by this particular client.
+func (self *Whisper) Protocols() []p2p.Protocol {
+	return []p2p.Protocol{self.protocol}
+}
+
+// Version returns the whisper sub-protocols version number.
+func (self *Whisper) Version() uint {
+	return self.protocol.Version
+}
+
+// todo: review. maybe we need to delete these identity-related functions, since the key moved to Filter
+// NewIdentity generates a new cryptographic identity for the client, and injects
+// it into the known identities for message decryption.
+func (self *Whisper) NewIdentity() *ecdsa.PrivateKey {
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+	if !validatePrivateKey(key) {
+		err = fmt.Errorf("Failed to generate valid key")
+		panic(err)
+	}
+	self.privateKeys[string(crypto.FromECDSAPub(&key.PublicKey))] = key
+	return key
+}
+
+// HasIdentity checks if the the whisper node is configured with the private key
+// of the specified public pair.
+func (self *Whisper) HasIdentity(key *ecdsa.PublicKey) bool {
+	return self.privateKeys[string(crypto.FromECDSAPub(key))] != nil
+}
+
+// GetIdentity retrieves the private key of the specified public identity.
+func (self *Whisper) GetIdentity(key *ecdsa.PublicKey) *ecdsa.PrivateKey {
+	return self.privateKeys[string(crypto.FromECDSAPub(key))]
+}
+
+// Watch installs a new message handler to run in case a matching packet arrives
+// from the whisper network.
+func (self *Whisper) Watch(f *Filter) int {
+	return self.filters.Install(f)
+}
+
+// Unwatch removes an installed message handler.
+func (self *Whisper) Unwatch(id int) {
+	self.filters.Uninstall(id)
+}
+
+// Send injects a message into the whisper send queue, to be distributed in the
+// network in the coming cycles.
+func (self *Whisper) Send(envelope *Envelope) error {
+	return self.add(envelope)
+}
+
+// Start implements node.Service, starting the background data propagation thread
+// of the Whisper protocol.
+func (self *Whisper) Start(*p2p.Server) error {
+	glog.V(logger.Info).Infoln("Whisper started")
+	go self.update()
+	return nil
+}
+
+// Stop implements node.Service, stopping the background data propagation thread
+// of the Whisper protocol.
+func (self *Whisper) Stop() error {
+	close(self.quit)
+	glog.V(logger.Info).Infoln("Whisper stopped")
+	return nil
+}
+
+// handlePeer is called by the underlying P2P layer when the whisper sub-protocol
+// connection is negotiated.
+func (self *Whisper) handlePeer(peer *p2p.Peer, rw p2p.MsgReadWriter) error {
+	// Create the new peer and start tracking it
+	whisperPeer := newPeer(self, peer, rw)
+
+	self.peerMu.Lock()
+	self.peers[whisperPeer] = struct{}{}
+	self.peerMu.Unlock()
+
+	defer func() {
+		self.peerMu.Lock()
+		delete(self.peers, whisperPeer)
+		self.peerMu.Unlock()
+	}()
+
+	// Run the peer handshake and state updates
+	if err := whisperPeer.handshake(); err != nil {
+		return err
+	}
+	whisperPeer.start()
+	defer whisperPeer.stop()
+
+	// Read and process inbound messages directly to merge into client-global state
+	for {
+		// Fetch the next packet and decode the contained envelopes
+		packet, err := rw.ReadMsg()
+		if err != nil {
+			return err
+		}
+		var envelopes []*Envelope
+		if err := packet.Decode(&envelopes); err != nil {
+			glog.V(logger.Info).Infof("%v: failed to decode envelope: %v", peer, err)
+			continue
+		}
+		// Inject all envelopes into the internal pool
+		for _, envelope := range envelopes {
+			if err := self.add(envelope); err != nil {
+				// TODO Punish peer here. Invalid envelope.
+				glog.V(logger.Debug).Infof("%v: failed to pool envelope: %v", peer, err)
+			}
+			whisperPeer.mark(envelope)
+		}
+	}
+}
+
+// add inserts a new envelope into the message pool to be distributed within the
+// whisper network. It also inserts the envelope into the expiration pool at the
+// appropriate time-stamp.
+func (self *Whisper) add(envelope *Envelope) error {
+	self.poolMu.Lock()
+	defer self.poolMu.Unlock()
+
+	// short circuit when a received envelope has already expired
+	if envelope.Expiry < uint32(time.Now().Unix()) {
+		return nil
+	}
+
+	// Insert the message into the tracked pool
+	hash := envelope.Hash()
+	if _, ok := self.envelopes[hash]; ok {
+		glog.V(logger.Detail).Infof("whisper envelope already cached: %x\n", envelope)
+		return nil
+	}
+	self.envelopes[hash] = envelope
+
+	// Insert the message into the expiration pool for later removal
+	if self.expirations[envelope.Expiry] == nil {
+		self.expirations[envelope.Expiry] = set.NewNonTS()
+	}
+	if !self.expirations[envelope.Expiry].Has(hash) {
+		self.expirations[envelope.Expiry].Add(hash)
+
+		// Notify the local node of a message arrival
+		go self.postEvent(envelope)
+	}
+	glog.V(logger.Detail).Infof("cached whisper envelope %x\n", envelope)
+	return nil
+}
+
+// postEvent delivers the message to the watchers.
+func (self *Whisper) postEvent(envelope *Envelope) {
+	self.filters.Notify(envelope)
+}
+
+// update loops until the lifetime of the whisper node, updating its internal
+// state by expiring stale messages from the pool.
+func (self *Whisper) update() {
+	// Start a ticker to check for expirations
+	expire := time.NewTicker(expirationCycle)
+
+	// Repeat updates until termination is requested
+	for {
+		select {
+		case <-expire.C:
+			self.expire()
+
+		case <-self.quit:
+			return
+		}
+	}
+}
+
+// expire iterates over all the expiration timestamps, removing all stale
+// messages from the pools.
+func (self *Whisper) expire() {
+	self.poolMu.Lock()
+	defer self.poolMu.Unlock()
+
+	now := uint32(time.Now().Unix())
+	for then, hashSet := range self.expirations {
+		// Short circuit if a future time
+		if then > now {
+			continue
+		}
+		// Dump all expired messages and remove timestamp
+		hashSet.Each(func(v interface{}) bool {
+			delete(self.envelopes, v.(common.Hash))
+			delete(self.messages, v.(common.Hash))
+			return true
+		})
+		self.expirations[then].Clear()
+	}
+}
+
+// envelopes retrieves all the messages currently pooled by the node.
+func (self *Whisper) Envelopes() []*Envelope {
+	self.poolMu.RLock()
+	defer self.poolMu.RUnlock()
+
+	all := make([]*Envelope, 0, len(self.envelopes))
+	for _, envelope := range self.envelopes {
+		all = append(all, envelope)
+	}
+	return all
+}
+
+// Messages retrieves all the currently pooled messages matching a filter id.
+func (self *Whisper) Messages(id int) []*ReceivedMessage {
+	self.poolMu.RLock()
+	defer self.poolMu.RUnlock()
+
+	result := make([]*ReceivedMessage, 0)
+	if filter := self.filters.Get(id); filter != nil {
+		for _, msg := range self.messages {
+			if filter.MatchMessage(msg) {
+				result = append(result, msg)
+			}
+		}
+	}
+	return result
+}
+
+func (self *Whisper) addDecryptedMessage(msg *ReceivedMessage) {
+	self.poolMu.Lock()
+	defer self.poolMu.Unlock()
+
+	self.messages[msg.EnvelopeHash] = msg
+}
+
+func validatePublicKey(k *ecdsa.PublicKey) bool {
+	return k != nil && k.X != nil && k.Y != nil
+}
+
+func validatePrivateKey(k *ecdsa.PrivateKey) bool {
+	if k == nil || k.D == nil {
+		return false
+	}
+	return validatePublicKey(&k.PublicKey)
+}