github.com/reapchain/go-reapchain@v0.2.15-0.20210609012950-9735c110c705/cmd/wnode/main.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of go-ethereum. 3 // 4 // go-ethereum is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU 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 // go-ethereum 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 General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>. 16 17 // This is a simple Whisper node. It could be used as a stand-alone bootstrap node. 18 // Also, could be used for different test and diagnostics purposes. 19 20 package main 21 22 import ( 23 "bufio" 24 "crypto/ecdsa" 25 "crypto/sha512" 26 "encoding/binary" 27 "encoding/hex" 28 "flag" 29 "fmt" 30 "io/ioutil" 31 "os" 32 "path/filepath" 33 "strconv" 34 "strings" 35 "time" 36 37 "github.com/ethereum/go-ethereum/cmd/utils" 38 "github.com/ethereum/go-ethereum/common" 39 "github.com/ethereum/go-ethereum/console" 40 "github.com/ethereum/go-ethereum/crypto" 41 "github.com/ethereum/go-ethereum/log" 42 "github.com/ethereum/go-ethereum/p2p" 43 "github.com/ethereum/go-ethereum/p2p/discover" 44 "github.com/ethereum/go-ethereum/p2p/nat" 45 "github.com/ethereum/go-ethereum/whisper/mailserver" 46 whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" 47 "golang.org/x/crypto/pbkdf2" 48 ) 49 50 const quitCommand = "~Q" 51 52 // singletons 53 var ( 54 server *p2p.Server 55 shh *whisper.Whisper 56 done chan struct{} 57 mailServer mailserver.WMailServer 58 59 input = bufio.NewReader(os.Stdin) 60 ) 61 62 // encryption 63 var ( 64 symKey []byte 65 pub *ecdsa.PublicKey 66 asymKey *ecdsa.PrivateKey 67 nodeid *ecdsa.PrivateKey 68 topic whisper.TopicType 69 asymKeyID string 70 filterID string 71 symPass string 72 msPassword string 73 ) 74 75 // cmd arguments 76 var ( 77 bootstrapMode = flag.Bool("standalone", false, "boostrap node: don't actively connect to peers, wait for incoming connections") 78 forwarderMode = flag.Bool("forwarder", false, "forwarder mode: only forward messages, neither send nor decrypt messages") 79 mailServerMode = flag.Bool("mailserver", false, "mail server mode: delivers expired messages on demand") 80 requestMail = flag.Bool("mailclient", false, "request expired messages from the bootstrap server") 81 asymmetricMode = flag.Bool("asym", false, "use asymmetric encryption") 82 generateKey = flag.Bool("generatekey", false, "generate and show the private key") 83 fileExMode = flag.Bool("fileexchange", false, "file exchange mode") 84 testMode = flag.Bool("test", false, "use of predefined parameters for diagnostics") 85 echoMode = flag.Bool("echo", false, "echo mode: prints some arguments for diagnostics") 86 87 argVerbosity = flag.Int("verbosity", int(log.LvlError), "log verbosity level") 88 argTTL = flag.Uint("ttl", 30, "time-to-live for messages in seconds") 89 argWorkTime = flag.Uint("work", 5, "work time in seconds") 90 argMaxSize = flag.Int("maxsize", whisper.DefaultMaxMessageLength, "max size of message") 91 argPoW = flag.Float64("pow", whisper.DefaultMinimumPoW, "PoW for normal messages in float format (e.g. 2.7)") 92 argServerPoW = flag.Float64("mspow", whisper.DefaultMinimumPoW, "PoW requirement for Mail Server request") 93 94 argIP = flag.String("ip", "", "IP address and port of this node (e.g. 127.0.0.1:30303)") 95 argPub = flag.String("pub", "", "public key for asymmetric encryption") 96 argDBPath = flag.String("dbpath", "", "path to the server's DB directory") 97 argIDFile = flag.String("idfile", "", "file name with node id (private key)") 98 argEnode = flag.String("boot", "", "bootstrap node you want to connect to (e.g. enode://e454......08d50@52.176.211.200:16428)") 99 argTopic = flag.String("topic", "", "topic in hexadecimal format (e.g. 70a4beef)") 100 argSaveDir = flag.String("savedir", "", "directory where incoming messages will be saved as files") 101 ) 102 103 func main() { 104 processArgs() 105 initialize() 106 run() 107 } 108 109 func processArgs() { 110 flag.Parse() 111 112 if len(*argIDFile) > 0 { 113 var err error 114 nodeid, err = crypto.LoadECDSA(*argIDFile) 115 if err != nil { 116 utils.Fatalf("Failed to load file [%s]: %s.", *argIDFile, err) 117 } 118 } 119 120 const enodePrefix = "enode://" 121 if len(*argEnode) > 0 { 122 if (*argEnode)[:len(enodePrefix)] != enodePrefix { 123 *argEnode = enodePrefix + *argEnode 124 } 125 } 126 127 if len(*argTopic) > 0 { 128 x, err := hex.DecodeString(*argTopic) 129 if err != nil { 130 utils.Fatalf("Failed to parse the topic: %s", err) 131 } 132 topic = whisper.BytesToTopic(x) 133 } 134 135 if *asymmetricMode && len(*argPub) > 0 { 136 pub = crypto.ToECDSAPub(common.FromHex(*argPub)) 137 if !isKeyValid(pub) { 138 utils.Fatalf("invalid public key") 139 } 140 } 141 142 if len(*argSaveDir) > 0 { 143 if _, err := os.Stat(*argSaveDir); os.IsNotExist(err) { 144 utils.Fatalf("Download directory '%s' does not exist", *argSaveDir) 145 } 146 } else if *fileExMode { 147 utils.Fatalf("Parameter 'savedir' is mandatory for file exchange mode") 148 } 149 150 if *echoMode { 151 echo() 152 } 153 } 154 155 func echo() { 156 fmt.Printf("ttl = %d \n", *argTTL) 157 fmt.Printf("workTime = %d \n", *argWorkTime) 158 fmt.Printf("pow = %f \n", *argPoW) 159 fmt.Printf("mspow = %f \n", *argServerPoW) 160 fmt.Printf("ip = %s \n", *argIP) 161 fmt.Printf("pub = %s \n", common.ToHex(crypto.FromECDSAPub(pub))) 162 fmt.Printf("idfile = %s \n", *argIDFile) 163 fmt.Printf("dbpath = %s \n", *argDBPath) 164 fmt.Printf("boot = %s \n", *argEnode) 165 } 166 167 func initialize() { 168 log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*argVerbosity), log.StreamHandler(os.Stderr, log.TerminalFormat(false)))) 169 170 done = make(chan struct{}) 171 var peers []*discover.Node 172 var err error 173 174 if *generateKey { 175 key, err := crypto.GenerateKey() 176 if err != nil { 177 utils.Fatalf("Failed to generate private key: %s", err) 178 } 179 k := hex.EncodeToString(crypto.FromECDSA(key)) 180 fmt.Printf("Random private key: %s \n", k) 181 os.Exit(0) 182 } 183 184 if *testMode { 185 symPass = "wwww" // ascii code: 0x77777777 186 msPassword = "wwww" 187 } 188 189 if *bootstrapMode { 190 if len(*argIP) == 0 { 191 argIP = scanLineA("Please enter your IP and port (e.g. 127.0.0.1:30348): ") 192 } 193 } else { 194 if len(*argEnode) == 0 { 195 argEnode = scanLineA("Please enter the peer's enode: ") 196 } 197 peer := discover.MustParseNode(*argEnode) 198 peers = append(peers, peer) 199 } 200 201 if *mailServerMode { 202 if len(msPassword) == 0 { 203 msPassword, err = console.Stdin.PromptPassword("Please enter the Mail Server password: ") 204 if err != nil { 205 utils.Fatalf("Failed to read Mail Server password: %s", err) 206 } 207 } 208 shh = whisper.New() 209 shh.RegisterServer(&mailServer) 210 mailServer.Init(shh, *argDBPath, msPassword, *argServerPoW) 211 } else { 212 shh = whisper.New() 213 } 214 215 if *argPoW != whisper.DefaultMinimumPoW { 216 err := shh.SetMinimumPoW(*argPoW) 217 if err != nil { 218 utils.Fatalf("Failed to set PoW: %s", err) 219 } 220 } 221 222 if *argMaxSize != whisper.DefaultMaxMessageLength { 223 err := shh.SetMaxMessageLength(*argMaxSize) 224 if err != nil { 225 utils.Fatalf("Failed to set max message size: %s", err) 226 } 227 } 228 229 asymKeyID, err = shh.NewKeyPair() 230 if err != nil { 231 utils.Fatalf("Failed to generate a new key pair: %s", err) 232 } 233 234 asymKey, err = shh.GetPrivateKey(asymKeyID) 235 if err != nil { 236 utils.Fatalf("Failed to retrieve a new key pair: %s", err) 237 } 238 239 if nodeid == nil { 240 tmpID, err := shh.NewKeyPair() 241 if err != nil { 242 utils.Fatalf("Failed to generate a new key pair: %s", err) 243 } 244 245 nodeid, err = shh.GetPrivateKey(tmpID) 246 if err != nil { 247 utils.Fatalf("Failed to retrieve a new key pair: %s", err) 248 } 249 } 250 251 maxPeers := 80 252 if *bootstrapMode { 253 maxPeers = 800 254 } 255 256 server = &p2p.Server{ 257 Config: p2p.Config{ 258 PrivateKey: nodeid, 259 MaxPeers: maxPeers, 260 Name: common.MakeName("wnode", "5.0"), 261 Protocols: shh.Protocols(), 262 ListenAddr: *argIP, 263 NAT: nat.Any(), 264 BootstrapNodes: peers, 265 StaticNodes: peers, 266 TrustedNodes: peers, 267 }, 268 } 269 } 270 271 func startServer() { 272 err := server.Start() 273 if err != nil { 274 utils.Fatalf("Failed to start Whisper peer: %s.", err) 275 } 276 277 fmt.Printf("my public key: %s \n", common.ToHex(crypto.FromECDSAPub(&asymKey.PublicKey))) 278 fmt.Println(server.NodeInfo().Enode) 279 280 if *bootstrapMode { 281 configureNode() 282 fmt.Println("Bootstrap Whisper node started") 283 } else { 284 fmt.Println("Whisper node started") 285 // first see if we can establish connection, then ask for user input 286 waitForConnection(true) 287 configureNode() 288 } 289 290 if !*forwarderMode { 291 fmt.Printf("Please type the message. To quit type: '%s'\n", quitCommand) 292 } 293 } 294 295 func isKeyValid(k *ecdsa.PublicKey) bool { 296 return k.X != nil && k.Y != nil 297 } 298 299 func configureNode() { 300 var err error 301 var p2pAccept bool 302 303 if *forwarderMode { 304 return 305 } 306 307 if *asymmetricMode { 308 if len(*argPub) == 0 { 309 s := scanLine("Please enter the peer's public key: ") 310 b := common.FromHex(s) 311 if b == nil { 312 utils.Fatalf("Error: can not convert hexadecimal string") 313 } 314 pub = crypto.ToECDSAPub(b) 315 if !isKeyValid(pub) { 316 utils.Fatalf("Error: invalid public key") 317 } 318 } 319 } 320 321 if *requestMail { 322 p2pAccept = true 323 if len(msPassword) == 0 { 324 msPassword, err = console.Stdin.PromptPassword("Please enter the Mail Server password: ") 325 if err != nil { 326 utils.Fatalf("Failed to read Mail Server password: %s", err) 327 } 328 } 329 } 330 331 if !*asymmetricMode && !*forwarderMode { 332 if len(symPass) == 0 { 333 symPass, err = console.Stdin.PromptPassword("Please enter the password for symmetric encryption: ") 334 if err != nil { 335 utils.Fatalf("Failed to read passphrase: %v", err) 336 } 337 } 338 339 symKeyID, err := shh.AddSymKeyFromPassword(symPass) 340 if err != nil { 341 utils.Fatalf("Failed to create symmetric key: %s", err) 342 } 343 symKey, err = shh.GetSymKey(symKeyID) 344 if err != nil { 345 utils.Fatalf("Failed to save symmetric key: %s", err) 346 } 347 if len(*argTopic) == 0 { 348 generateTopic([]byte(symPass)) 349 } 350 351 fmt.Printf("Filter is configured for the topic: %x \n", topic) 352 } 353 354 if *mailServerMode { 355 if len(*argDBPath) == 0 { 356 argDBPath = scanLineA("Please enter the path to DB file: ") 357 } 358 } 359 360 filter := whisper.Filter{ 361 KeySym: symKey, 362 KeyAsym: asymKey, 363 Topics: [][]byte{topic[:]}, 364 AllowP2P: p2pAccept, 365 } 366 filterID, err = shh.Subscribe(&filter) 367 if err != nil { 368 utils.Fatalf("Failed to install filter: %s", err) 369 } 370 } 371 372 func generateTopic(password []byte) { 373 x := pbkdf2.Key(password, password, 4096, 128, sha512.New) 374 for i := 0; i < len(x); i++ { 375 topic[i%whisper.TopicLength] ^= x[i] 376 } 377 } 378 379 func waitForConnection(timeout bool) { 380 var cnt int 381 var connected bool 382 for !connected { 383 time.Sleep(time.Millisecond * 50) 384 connected = server.PeerCount() > 0 385 if timeout { 386 cnt++ 387 if cnt > 1000 { 388 utils.Fatalf("Timeout expired, failed to connect") 389 } 390 } 391 } 392 393 fmt.Println("Connected to peer.") 394 } 395 396 func run() { 397 defer mailServer.Close() 398 startServer() 399 defer server.Stop() 400 shh.Start(nil) 401 defer shh.Stop() 402 403 if !*forwarderMode { 404 go messageLoop() 405 } 406 407 if *requestMail { 408 requestExpiredMessagesLoop() 409 } else if *fileExMode { 410 sendFilesLoop() 411 } else { 412 sendLoop() 413 } 414 } 415 416 func sendLoop() { 417 for { 418 s := scanLine("") 419 if s == quitCommand { 420 fmt.Println("Quit command received") 421 close(done) 422 break 423 } 424 sendMsg([]byte(s)) 425 426 if *asymmetricMode { 427 // print your own message for convenience, 428 // because in asymmetric mode it is impossible to decrypt it 429 timestamp := time.Now().Unix() 430 from := crypto.PubkeyToAddress(asymKey.PublicKey) 431 fmt.Printf("\n%d <%x>: %s\n", timestamp, from, s) 432 } 433 } 434 } 435 436 func sendFilesLoop() { 437 for { 438 s := scanLine("") 439 if s == quitCommand { 440 fmt.Println("Quit command received") 441 close(done) 442 break 443 } 444 b, err := ioutil.ReadFile(s) 445 if err != nil { 446 fmt.Printf(">>> Error: %s \n", err) 447 continue 448 } else { 449 h := sendMsg(b) 450 if (h == common.Hash{}) { 451 fmt.Printf(">>> Error: message was not sent \n") 452 } else { 453 timestamp := time.Now().Unix() 454 from := crypto.PubkeyToAddress(asymKey.PublicKey) 455 fmt.Printf("\n%d <%x>: sent message with hash %x\n", timestamp, from, h) 456 } 457 } 458 } 459 } 460 461 func scanLine(prompt string) string { 462 if len(prompt) > 0 { 463 fmt.Print(prompt) 464 } 465 txt, err := input.ReadString('\n') 466 if err != nil { 467 utils.Fatalf("input error: %s", err) 468 } 469 txt = strings.TrimRight(txt, "\n\r") 470 return txt 471 } 472 473 func scanLineA(prompt string) *string { 474 s := scanLine(prompt) 475 return &s 476 } 477 478 func scanUint(prompt string) uint32 { 479 s := scanLine(prompt) 480 i, err := strconv.Atoi(s) 481 if err != nil { 482 utils.Fatalf("Fail to parse the lower time limit: %s", err) 483 } 484 return uint32(i) 485 } 486 487 func sendMsg(payload []byte) common.Hash { 488 params := whisper.MessageParams{ 489 Src: asymKey, 490 Dst: pub, 491 KeySym: symKey, 492 Payload: payload, 493 Topic: topic, 494 TTL: uint32(*argTTL), 495 PoW: *argPoW, 496 WorkTime: uint32(*argWorkTime), 497 } 498 499 msg, err := whisper.NewSentMessage(¶ms) 500 if err != nil { 501 utils.Fatalf("failed to create new message: %s", err) 502 } 503 envelope, err := msg.Wrap(¶ms) 504 if err != nil { 505 fmt.Printf("failed to seal message: %v \n", err) 506 return common.Hash{} 507 } 508 509 err = shh.Send(envelope) 510 if err != nil { 511 fmt.Printf("failed to send message: %v \n", err) 512 return common.Hash{} 513 } 514 515 return envelope.Hash() 516 } 517 518 func messageLoop() { 519 f := shh.GetFilter(filterID) 520 if f == nil { 521 utils.Fatalf("filter is not installed") 522 } 523 524 ticker := time.NewTicker(time.Millisecond * 50) 525 526 for { 527 select { 528 case <-ticker.C: 529 messages := f.Retrieve() 530 for _, msg := range messages { 531 if *fileExMode || len(msg.Payload) > 2048 { 532 writeMessageToFile(*argSaveDir, msg) 533 } else { 534 printMessageInfo(msg) 535 } 536 } 537 case <-done: 538 return 539 } 540 } 541 } 542 543 func printMessageInfo(msg *whisper.ReceivedMessage) { 544 timestamp := fmt.Sprintf("%d", msg.Sent) // unix timestamp for diagnostics 545 text := string(msg.Payload) 546 547 var address common.Address 548 if msg.Src != nil { 549 address = crypto.PubkeyToAddress(*msg.Src) 550 } 551 552 if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) { 553 fmt.Printf("\n%s <%x>: %s\n", timestamp, address, text) // message from myself 554 } else { 555 fmt.Printf("\n%s [%x]: %s\n", timestamp, address, text) // message from a peer 556 } 557 } 558 559 func writeMessageToFile(dir string, msg *whisper.ReceivedMessage) { 560 timestamp := fmt.Sprintf("%d", msg.Sent) 561 name := fmt.Sprintf("%x", msg.EnvelopeHash) 562 563 var address common.Address 564 if msg.Src != nil { 565 address = crypto.PubkeyToAddress(*msg.Src) 566 } 567 568 if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) { 569 // message from myself: don't save, only report 570 fmt.Printf("\n%s <%x>: message received: '%s'\n", timestamp, address, name) 571 } else if len(dir) > 0 { 572 fullpath := filepath.Join(dir, name) 573 err := ioutil.WriteFile(fullpath, msg.Payload, 0644) 574 if err != nil { 575 fmt.Printf("\n%s {%x}: message received but not saved: %s\n", timestamp, address, err) 576 } else { 577 fmt.Printf("\n%s {%x}: message received and saved as '%s' (%d bytes)\n", timestamp, address, name, len(msg.Payload)) 578 } 579 } else { 580 fmt.Printf("\n%s {%x}: big message received (%d bytes), but not saved: %s\n", timestamp, address, len(msg.Payload), name) 581 } 582 } 583 584 func requestExpiredMessagesLoop() { 585 var key, peerID []byte 586 var timeLow, timeUpp uint32 587 var t string 588 var xt, empty whisper.TopicType 589 590 keyID, err := shh.AddSymKeyFromPassword(msPassword) 591 if err != nil { 592 utils.Fatalf("Failed to create symmetric key for mail request: %s", err) 593 } 594 key, err = shh.GetSymKey(keyID) 595 if err != nil { 596 utils.Fatalf("Failed to save symmetric key for mail request: %s", err) 597 } 598 peerID = extractIdFromEnode(*argEnode) 599 shh.AllowP2PMessagesFromPeer(peerID) 600 601 for { 602 timeLow = scanUint("Please enter the lower limit of the time range (unix timestamp): ") 603 timeUpp = scanUint("Please enter the upper limit of the time range (unix timestamp): ") 604 t = scanLine("Please enter the topic (hexadecimal): ") 605 if len(t) >= whisper.TopicLength*2 { 606 x, err := hex.DecodeString(t) 607 if err != nil { 608 utils.Fatalf("Failed to parse the topic: %s", err) 609 } 610 xt = whisper.BytesToTopic(x) 611 } 612 if timeUpp == 0 { 613 timeUpp = 0xFFFFFFFF 614 } 615 616 data := make([]byte, 8+whisper.TopicLength) 617 binary.BigEndian.PutUint32(data, timeLow) 618 binary.BigEndian.PutUint32(data[4:], timeUpp) 619 copy(data[8:], xt[:]) 620 if xt == empty { 621 data = data[:8] 622 } 623 624 var params whisper.MessageParams 625 params.PoW = *argServerPoW 626 params.Payload = data 627 params.KeySym = key 628 params.Src = nodeid 629 params.WorkTime = 5 630 631 msg, err := whisper.NewSentMessage(¶ms) 632 if err != nil { 633 utils.Fatalf("failed to create new message: %s", err) 634 } 635 env, err := msg.Wrap(¶ms) 636 if err != nil { 637 utils.Fatalf("Wrap failed: %s", err) 638 } 639 640 err = shh.RequestHistoricMessages(peerID, env) 641 if err != nil { 642 utils.Fatalf("Failed to send P2P message: %s", err) 643 } 644 645 time.Sleep(time.Second * 5) 646 } 647 } 648 649 func extractIdFromEnode(s string) []byte { 650 n, err := discover.ParseNode(s) 651 if err != nil { 652 utils.Fatalf("Failed to parse enode: %s", err) 653 } 654 return n.ID[:] 655 }