github.com/n1ghtfa1l/go-vnt@v0.6.4-alpha.6/whisper/mailserver/mailserver.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package mailserver 18 19 import ( 20 "encoding/binary" 21 "fmt" 22 23 "github.com/syndtr/goleveldb/leveldb" 24 "github.com/syndtr/goleveldb/leveldb/util" 25 "github.com/vntchain/go-vnt/common" 26 "github.com/vntchain/go-vnt/crypto" 27 "github.com/vntchain/go-vnt/log" 28 "github.com/vntchain/go-vnt/rlp" 29 whisper "github.com/vntchain/go-vnt/whisper/whisperv6" 30 31 libp2p "github.com/libp2p/go-libp2p-peer" 32 ) 33 34 type WMailServer struct { 35 db *leveldb.DB 36 w *whisper.Whisper 37 pow float64 38 key []byte 39 } 40 41 type DBKey struct { 42 timestamp uint32 43 hash common.Hash 44 raw []byte 45 } 46 47 func NewDbKey(t uint32, h common.Hash) *DBKey { 48 const sz = common.HashLength + 4 49 var k DBKey 50 k.timestamp = t 51 k.hash = h 52 k.raw = make([]byte, sz) 53 binary.BigEndian.PutUint32(k.raw, k.timestamp) 54 copy(k.raw[4:], k.hash[:]) 55 return &k 56 } 57 58 func (s *WMailServer) Init(shh *whisper.Whisper, path string, password string, pow float64) error { 59 var err error 60 if len(path) == 0 { 61 return fmt.Errorf("DB file is not specified") 62 } 63 64 if len(password) == 0 { 65 return fmt.Errorf("password is not specified") 66 } 67 68 s.db, err = leveldb.OpenFile(path, nil) 69 if err != nil { 70 return fmt.Errorf("open DB file: %s", err) 71 } 72 73 s.w = shh 74 s.pow = pow 75 76 MailServerKeyID, err := s.w.AddSymKeyFromPassword(password) 77 if err != nil { 78 return fmt.Errorf("create symmetric key: %s", err) 79 } 80 s.key, err = s.w.GetSymKey(MailServerKeyID) 81 if err != nil { 82 return fmt.Errorf("save symmetric key: %s", err) 83 } 84 return nil 85 } 86 87 func (s *WMailServer) Close() { 88 if s.db != nil { 89 s.db.Close() 90 } 91 } 92 93 func (s *WMailServer) Archive(env *whisper.Envelope) { 94 key := NewDbKey(env.Expiry-env.TTL, env.Hash()) 95 rawEnvelope, err := rlp.EncodeToBytes(env) 96 if err != nil { 97 log.Error(fmt.Sprintf("rlp.EncodeToBytes failed: %s", err)) 98 } else { 99 err = s.db.Put(key.raw, rawEnvelope, nil) 100 if err != nil { 101 log.Error(fmt.Sprintf("Writing to DB failed: %s", err)) 102 } 103 } 104 } 105 106 func (s *WMailServer) DeliverMail(peer *whisper.Peer, request *whisper.Envelope) { 107 if peer == nil { 108 log.Error("Whisper peer is nil") 109 return 110 } 111 112 ok, lower, upper, bloom := s.validateRequest(peer.ID(), request) 113 if ok { 114 s.processRequest(peer, lower, upper, bloom) 115 } 116 } 117 118 func (s *WMailServer) processRequest(peer *whisper.Peer, lower, upper uint32, bloom []byte) []*whisper.Envelope { 119 ret := make([]*whisper.Envelope, 0) 120 var err error 121 var zero common.Hash 122 kl := NewDbKey(lower, zero) 123 ku := NewDbKey(upper, zero) 124 i := s.db.NewIterator(&util.Range{Start: kl.raw, Limit: ku.raw}, nil) 125 defer i.Release() 126 127 for i.Next() { 128 var envelope whisper.Envelope 129 err = rlp.DecodeBytes(i.Value(), &envelope) 130 if err != nil { 131 log.Error(fmt.Sprintf("RLP decoding failed: %s", err)) 132 } 133 134 if whisper.BloomFilterMatch(bloom, envelope.Bloom()) { 135 if peer == nil { 136 // used for test purposes 137 ret = append(ret, &envelope) 138 } else { 139 err = s.w.SendP2PDirect(peer, &envelope) 140 if err != nil { 141 log.Error(fmt.Sprintf("Failed to send direct message to peer: %s", err)) 142 return nil 143 } 144 } 145 } 146 } 147 148 err = i.Error() 149 if err != nil { 150 log.Error(fmt.Sprintf("Level DB iterator error: %s", err)) 151 } 152 153 return ret 154 } 155 156 func (s *WMailServer) validateRequest(peerID libp2p.ID, request *whisper.Envelope) (bool, uint32, uint32, []byte) { 157 if s.pow > 0.0 && request.PoW() < s.pow { 158 return false, 0, 0, nil 159 } 160 161 f := whisper.Filter{KeySym: s.key} 162 decrypted := request.Open(&f) 163 if decrypted == nil { 164 log.Warn(fmt.Sprintf("Failed to decrypt p2p request")) 165 return false, 0, 0, nil 166 } 167 168 src := crypto.FromECDSAPub(decrypted.Src) 169 if len(src)-len(peerID) == 1 { 170 src = src[1:] 171 } 172 173 // if you want to check the signature, you can do it here. e.g.: 174 // if !bytes.Equal(peerID, src) { 175 if src == nil { 176 log.Warn(fmt.Sprintf("Wrong signature of p2p request")) 177 return false, 0, 0, nil 178 } 179 180 var bloom []byte 181 payloadSize := len(decrypted.Payload) 182 if payloadSize < 8 { 183 log.Warn(fmt.Sprintf("Undersized p2p request")) 184 return false, 0, 0, nil 185 } else if payloadSize == 8 { 186 bloom = whisper.MakeFullNodeBloom() 187 } else if payloadSize < 8+whisper.BloomFilterSize { 188 log.Warn(fmt.Sprintf("Undersized bloom filter in p2p request")) 189 return false, 0, 0, nil 190 } else { 191 bloom = decrypted.Payload[8 : 8+whisper.BloomFilterSize] 192 } 193 194 lower := binary.BigEndian.Uint32(decrypted.Payload[:4]) 195 upper := binary.BigEndian.Uint32(decrypted.Payload[4:8]) 196 return true, lower, upper, bloom 197 }