github.com/alexanderbez/go-ethereum@v1.8.17-0.20181024144731-0a57b29f0c8e/cmd/faucet/faucet.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 // faucet is a Ether faucet backed by a light client. 18 package main 19 20 //go:generate go-bindata -nometadata -o website.go faucet.html 21 //go:generate gofmt -w -s website.go 22 23 import ( 24 "bytes" 25 "context" 26 "encoding/json" 27 "errors" 28 "flag" 29 "fmt" 30 "html/template" 31 "io/ioutil" 32 "math" 33 "math/big" 34 "net/http" 35 "net/url" 36 "os" 37 "path/filepath" 38 "regexp" 39 "strconv" 40 "strings" 41 "sync" 42 "time" 43 44 "github.com/ethereum/go-ethereum/accounts" 45 "github.com/ethereum/go-ethereum/accounts/keystore" 46 "github.com/ethereum/go-ethereum/common" 47 "github.com/ethereum/go-ethereum/core" 48 "github.com/ethereum/go-ethereum/core/types" 49 "github.com/ethereum/go-ethereum/eth" 50 "github.com/ethereum/go-ethereum/eth/downloader" 51 "github.com/ethereum/go-ethereum/ethclient" 52 "github.com/ethereum/go-ethereum/ethstats" 53 "github.com/ethereum/go-ethereum/les" 54 "github.com/ethereum/go-ethereum/log" 55 "github.com/ethereum/go-ethereum/node" 56 "github.com/ethereum/go-ethereum/p2p" 57 "github.com/ethereum/go-ethereum/p2p/discover" 58 "github.com/ethereum/go-ethereum/p2p/discv5" 59 "github.com/ethereum/go-ethereum/p2p/nat" 60 "github.com/ethereum/go-ethereum/params" 61 "golang.org/x/net/websocket" 62 ) 63 64 var ( 65 genesisFlag = flag.String("genesis", "", "Genesis json file to seed the chain with") 66 apiPortFlag = flag.Int("apiport", 8080, "Listener port for the HTTP API connection") 67 ethPortFlag = flag.Int("ethport", 30303, "Listener port for the devp2p connection") 68 bootFlag = flag.String("bootnodes", "", "Comma separated bootnode enode URLs to seed with") 69 netFlag = flag.Uint64("network", 0, "Network ID to use for the Ethereum protocol") 70 statsFlag = flag.String("ethstats", "", "Ethstats network monitoring auth string") 71 72 netnameFlag = flag.String("faucet.name", "", "Network name to assign to the faucet") 73 payoutFlag = flag.Int("faucet.amount", 1, "Number of Ethers to pay out per user request") 74 minutesFlag = flag.Int("faucet.minutes", 1440, "Number of minutes to wait between funding rounds") 75 tiersFlag = flag.Int("faucet.tiers", 3, "Number of funding tiers to enable (x3 time, x2.5 funds)") 76 77 accJSONFlag = flag.String("account.json", "", "Key json file to fund user requests with") 78 accPassFlag = flag.String("account.pass", "", "Decryption password to access faucet funds") 79 80 captchaToken = flag.String("captcha.token", "", "Recaptcha site key to authenticate client side") 81 captchaSecret = flag.String("captcha.secret", "", "Recaptcha secret key to authenticate server side") 82 83 noauthFlag = flag.Bool("noauth", false, "Enables funding requests without authentication") 84 logFlag = flag.Int("loglevel", 3, "Log level to use for Ethereum and the faucet") 85 ) 86 87 var ( 88 ether = new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil) 89 ) 90 91 func main() { 92 // Parse the flags and set up the logger to print everything requested 93 flag.Parse() 94 log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*logFlag), log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) 95 96 // Construct the payout tiers 97 amounts := make([]string, *tiersFlag) 98 periods := make([]string, *tiersFlag) 99 for i := 0; i < *tiersFlag; i++ { 100 // Calculate the amount for the next tier and format it 101 amount := float64(*payoutFlag) * math.Pow(2.5, float64(i)) 102 amounts[i] = fmt.Sprintf("%s Ethers", strconv.FormatFloat(amount, 'f', -1, 64)) 103 if amount == 1 { 104 amounts[i] = strings.TrimSuffix(amounts[i], "s") 105 } 106 // Calculate the period for the next tier and format it 107 period := *minutesFlag * int(math.Pow(3, float64(i))) 108 periods[i] = fmt.Sprintf("%d mins", period) 109 if period%60 == 0 { 110 period /= 60 111 periods[i] = fmt.Sprintf("%d hours", period) 112 113 if period%24 == 0 { 114 period /= 24 115 periods[i] = fmt.Sprintf("%d days", period) 116 } 117 } 118 if period == 1 { 119 periods[i] = strings.TrimSuffix(periods[i], "s") 120 } 121 } 122 // Load up and render the faucet website 123 tmpl, err := Asset("faucet.html") 124 if err != nil { 125 log.Crit("Failed to load the faucet template", "err", err) 126 } 127 website := new(bytes.Buffer) 128 err = template.Must(template.New("").Parse(string(tmpl))).Execute(website, map[string]interface{}{ 129 "Network": *netnameFlag, 130 "Amounts": amounts, 131 "Periods": periods, 132 "Recaptcha": *captchaToken, 133 "NoAuth": *noauthFlag, 134 }) 135 if err != nil { 136 log.Crit("Failed to render the faucet template", "err", err) 137 } 138 // Load and parse the genesis block requested by the user 139 blob, err := ioutil.ReadFile(*genesisFlag) 140 if err != nil { 141 log.Crit("Failed to read genesis block contents", "genesis", *genesisFlag, "err", err) 142 } 143 genesis := new(core.Genesis) 144 if err = json.Unmarshal(blob, genesis); err != nil { 145 log.Crit("Failed to parse genesis block json", "err", err) 146 } 147 // Convert the bootnodes to internal enode representations 148 var enodes []*discv5.Node 149 for _, boot := range strings.Split(*bootFlag, ",") { 150 if url, err := discv5.ParseNode(boot); err == nil { 151 enodes = append(enodes, url) 152 } else { 153 log.Error("Failed to parse bootnode URL", "url", boot, "err", err) 154 } 155 } 156 // Load up the account key and decrypt its password 157 if blob, err = ioutil.ReadFile(*accPassFlag); err != nil { 158 log.Crit("Failed to read account password contents", "file", *accPassFlag, "err", err) 159 } 160 // Delete trailing newline in password 161 pass := strings.TrimSuffix(string(blob), "\n") 162 163 ks := keystore.NewKeyStore(filepath.Join(os.Getenv("HOME"), ".faucet", "keys"), keystore.StandardScryptN, keystore.StandardScryptP) 164 if blob, err = ioutil.ReadFile(*accJSONFlag); err != nil { 165 log.Crit("Failed to read account key contents", "file", *accJSONFlag, "err", err) 166 } 167 acc, err := ks.Import(blob, pass, pass) 168 if err != nil { 169 log.Crit("Failed to import faucet signer account", "err", err) 170 } 171 ks.Unlock(acc, pass) 172 173 // Assemble and start the faucet light service 174 faucet, err := newFaucet(genesis, *ethPortFlag, enodes, *netFlag, *statsFlag, ks, website.Bytes()) 175 if err != nil { 176 log.Crit("Failed to start faucet", "err", err) 177 } 178 defer faucet.close() 179 180 if err := faucet.listenAndServe(*apiPortFlag); err != nil { 181 log.Crit("Failed to launch faucet API", "err", err) 182 } 183 } 184 185 // request represents an accepted funding request. 186 type request struct { 187 Avatar string `json:"avatar"` // Avatar URL to make the UI nicer 188 Account common.Address `json:"account"` // Ethereum address being funded 189 Time time.Time `json:"time"` // Timestamp when the request was accepted 190 Tx *types.Transaction `json:"tx"` // Transaction funding the account 191 } 192 193 // faucet represents a crypto faucet backed by an Ethereum light client. 194 type faucet struct { 195 config *params.ChainConfig // Chain configurations for signing 196 stack *node.Node // Ethereum protocol stack 197 client *ethclient.Client // Client connection to the Ethereum chain 198 index []byte // Index page to serve up on the web 199 200 keystore *keystore.KeyStore // Keystore containing the single signer 201 account accounts.Account // Account funding user faucet requests 202 head *types.Header // Current head header of the faucet 203 balance *big.Int // Current balance of the faucet 204 nonce uint64 // Current pending nonce of the faucet 205 price *big.Int // Current gas price to issue funds with 206 207 conns []*websocket.Conn // Currently live websocket connections 208 timeouts map[string]time.Time // History of users and their funding timeouts 209 reqs []*request // Currently pending funding requests 210 update chan struct{} // Channel to signal request updates 211 212 lock sync.RWMutex // Lock protecting the faucet's internals 213 } 214 215 func newFaucet(genesis *core.Genesis, port int, enodes []*discv5.Node, network uint64, stats string, ks *keystore.KeyStore, index []byte) (*faucet, error) { 216 // Assemble the raw devp2p protocol stack 217 stack, err := node.New(&node.Config{ 218 Name: "geth", 219 Version: params.VersionWithMeta, 220 DataDir: filepath.Join(os.Getenv("HOME"), ".faucet"), 221 P2P: p2p.Config{ 222 NAT: nat.Any(), 223 NoDiscovery: true, 224 DiscoveryV5: true, 225 ListenAddr: fmt.Sprintf(":%d", port), 226 MaxPeers: 25, 227 BootstrapNodesV5: enodes, 228 }, 229 }) 230 if err != nil { 231 return nil, err 232 } 233 // Assemble the Ethereum light client protocol 234 if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 235 cfg := eth.DefaultConfig 236 cfg.SyncMode = downloader.LightSync 237 cfg.NetworkId = network 238 cfg.Genesis = genesis 239 return les.New(ctx, &cfg) 240 }); err != nil { 241 return nil, err 242 } 243 // Assemble the ethstats monitoring and reporting service' 244 if stats != "" { 245 if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 246 var serv *les.LightEthereum 247 ctx.Service(&serv) 248 return ethstats.New(stats, nil, serv) 249 }); err != nil { 250 return nil, err 251 } 252 } 253 // Boot up the client and ensure it connects to bootnodes 254 if err := stack.Start(); err != nil { 255 return nil, err 256 } 257 for _, boot := range enodes { 258 old, _ := discover.ParseNode(boot.String()) 259 stack.Server().AddPeer(old) 260 } 261 // Attach to the client and retrieve and interesting metadatas 262 api, err := stack.Attach() 263 if err != nil { 264 stack.Stop() 265 return nil, err 266 } 267 client := ethclient.NewClient(api) 268 269 return &faucet{ 270 config: genesis.Config, 271 stack: stack, 272 client: client, 273 index: index, 274 keystore: ks, 275 account: ks.Accounts()[0], 276 timeouts: make(map[string]time.Time), 277 update: make(chan struct{}, 1), 278 }, nil 279 } 280 281 // close terminates the Ethereum connection and tears down the faucet. 282 func (f *faucet) close() error { 283 return f.stack.Stop() 284 } 285 286 // listenAndServe registers the HTTP handlers for the faucet and boots it up 287 // for service user funding requests. 288 func (f *faucet) listenAndServe(port int) error { 289 go f.loop() 290 291 http.HandleFunc("/", f.webHandler) 292 http.Handle("/api", websocket.Handler(f.apiHandler)) 293 294 return http.ListenAndServe(fmt.Sprintf(":%d", port), nil) 295 } 296 297 // webHandler handles all non-api requests, simply flattening and returning the 298 // faucet website. 299 func (f *faucet) webHandler(w http.ResponseWriter, r *http.Request) { 300 w.Write(f.index) 301 } 302 303 // apiHandler handles requests for Ether grants and transaction statuses. 304 func (f *faucet) apiHandler(conn *websocket.Conn) { 305 // Start tracking the connection and drop at the end 306 defer conn.Close() 307 308 f.lock.Lock() 309 f.conns = append(f.conns, conn) 310 f.lock.Unlock() 311 312 defer func() { 313 f.lock.Lock() 314 for i, c := range f.conns { 315 if c == conn { 316 f.conns = append(f.conns[:i], f.conns[i+1:]...) 317 break 318 } 319 } 320 f.lock.Unlock() 321 }() 322 // Gather the initial stats from the network to report 323 var ( 324 head *types.Header 325 balance *big.Int 326 nonce uint64 327 err error 328 ) 329 for head == nil || balance == nil { 330 // Retrieve the current stats cached by the faucet 331 f.lock.RLock() 332 if f.head != nil { 333 head = types.CopyHeader(f.head) 334 } 335 if f.balance != nil { 336 balance = new(big.Int).Set(f.balance) 337 } 338 nonce = f.nonce 339 f.lock.RUnlock() 340 341 if head == nil || balance == nil { 342 // Report the faucet offline until initial stats are ready 343 if err = sendError(conn, errors.New("Faucet offline")); err != nil { 344 log.Warn("Failed to send faucet error to client", "err", err) 345 return 346 } 347 time.Sleep(3 * time.Second) 348 } 349 } 350 // Send over the initial stats and the latest header 351 if err = send(conn, map[string]interface{}{ 352 "funds": new(big.Int).Div(balance, ether), 353 "funded": nonce, 354 "peers": f.stack.Server().PeerCount(), 355 "requests": f.reqs, 356 }, 3*time.Second); err != nil { 357 log.Warn("Failed to send initial stats to client", "err", err) 358 return 359 } 360 if err = send(conn, head, 3*time.Second); err != nil { 361 log.Warn("Failed to send initial header to client", "err", err) 362 return 363 } 364 // Keep reading requests from the websocket until the connection breaks 365 for { 366 // Fetch the next funding request and validate against github 367 var msg struct { 368 URL string `json:"url"` 369 Tier uint `json:"tier"` 370 Captcha string `json:"captcha"` 371 } 372 if err = websocket.JSON.Receive(conn, &msg); err != nil { 373 return 374 } 375 if !*noauthFlag && !strings.HasPrefix(msg.URL, "https://gist.github.com/") && !strings.HasPrefix(msg.URL, "https://twitter.com/") && 376 !strings.HasPrefix(msg.URL, "https://plus.google.com/") && !strings.HasPrefix(msg.URL, "https://www.facebook.com/") { 377 if err = sendError(conn, errors.New("URL doesn't link to supported services")); err != nil { 378 log.Warn("Failed to send URL error to client", "err", err) 379 return 380 } 381 continue 382 } 383 if msg.Tier >= uint(*tiersFlag) { 384 if err = sendError(conn, errors.New("Invalid funding tier requested")); err != nil { 385 log.Warn("Failed to send tier error to client", "err", err) 386 return 387 } 388 continue 389 } 390 log.Info("Faucet funds requested", "url", msg.URL, "tier", msg.Tier) 391 392 // If captcha verifications are enabled, make sure we're not dealing with a robot 393 if *captchaToken != "" { 394 form := url.Values{} 395 form.Add("secret", *captchaSecret) 396 form.Add("response", msg.Captcha) 397 398 res, err := http.PostForm("https://www.google.com/recaptcha/api/siteverify", form) 399 if err != nil { 400 if err = sendError(conn, err); err != nil { 401 log.Warn("Failed to send captcha post error to client", "err", err) 402 return 403 } 404 continue 405 } 406 var result struct { 407 Success bool `json:"success"` 408 Errors json.RawMessage `json:"error-codes"` 409 } 410 err = json.NewDecoder(res.Body).Decode(&result) 411 res.Body.Close() 412 if err != nil { 413 if err = sendError(conn, err); err != nil { 414 log.Warn("Failed to send captcha decode error to client", "err", err) 415 return 416 } 417 continue 418 } 419 if !result.Success { 420 log.Warn("Captcha verification failed", "err", string(result.Errors)) 421 if err = sendError(conn, errors.New("Beep-bop, you're a robot!")); err != nil { 422 log.Warn("Failed to send captcha failure to client", "err", err) 423 return 424 } 425 continue 426 } 427 } 428 // Retrieve the Ethereum address to fund, the requesting user and a profile picture 429 var ( 430 username string 431 avatar string 432 address common.Address 433 ) 434 switch { 435 case strings.HasPrefix(msg.URL, "https://gist.github.com/"): 436 if err = sendError(conn, errors.New("GitHub authentication discontinued at the official request of GitHub")); err != nil { 437 log.Warn("Failed to send GitHub deprecation to client", "err", err) 438 return 439 } 440 continue 441 case strings.HasPrefix(msg.URL, "https://twitter.com/"): 442 username, avatar, address, err = authTwitter(msg.URL) 443 case strings.HasPrefix(msg.URL, "https://plus.google.com/"): 444 username, avatar, address, err = authGooglePlus(msg.URL) 445 case strings.HasPrefix(msg.URL, "https://www.facebook.com/"): 446 username, avatar, address, err = authFacebook(msg.URL) 447 case *noauthFlag: 448 username, avatar, address, err = authNoAuth(msg.URL) 449 default: 450 err = errors.New("Something funky happened, please open an issue at https://github.com/ethereum/go-ethereum/issues") 451 } 452 if err != nil { 453 if err = sendError(conn, err); err != nil { 454 log.Warn("Failed to send prefix error to client", "err", err) 455 return 456 } 457 continue 458 } 459 log.Info("Faucet request valid", "url", msg.URL, "tier", msg.Tier, "user", username, "address", address) 460 461 // Ensure the user didn't request funds too recently 462 f.lock.Lock() 463 var ( 464 fund bool 465 timeout time.Time 466 ) 467 if timeout = f.timeouts[username]; time.Now().After(timeout) { 468 // User wasn't funded recently, create the funding transaction 469 amount := new(big.Int).Mul(big.NewInt(int64(*payoutFlag)), ether) 470 amount = new(big.Int).Mul(amount, new(big.Int).Exp(big.NewInt(5), big.NewInt(int64(msg.Tier)), nil)) 471 amount = new(big.Int).Div(amount, new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(msg.Tier)), nil)) 472 473 tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, 21000, f.price, nil) 474 signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainID) 475 if err != nil { 476 f.lock.Unlock() 477 if err = sendError(conn, err); err != nil { 478 log.Warn("Failed to send transaction creation error to client", "err", err) 479 return 480 } 481 continue 482 } 483 // Submit the transaction and mark as funded if successful 484 if err := f.client.SendTransaction(context.Background(), signed); err != nil { 485 f.lock.Unlock() 486 if err = sendError(conn, err); err != nil { 487 log.Warn("Failed to send transaction transmission error to client", "err", err) 488 return 489 } 490 continue 491 } 492 f.reqs = append(f.reqs, &request{ 493 Avatar: avatar, 494 Account: address, 495 Time: time.Now(), 496 Tx: signed, 497 }) 498 f.timeouts[username] = time.Now().Add(time.Duration(*minutesFlag*int(math.Pow(3, float64(msg.Tier)))) * time.Minute) 499 fund = true 500 } 501 f.lock.Unlock() 502 503 // Send an error if too frequent funding, othewise a success 504 if !fund { 505 if err = sendError(conn, fmt.Errorf("%s left until next allowance", common.PrettyDuration(timeout.Sub(time.Now())))); err != nil { // nolint: gosimple 506 log.Warn("Failed to send funding error to client", "err", err) 507 return 508 } 509 continue 510 } 511 if err = sendSuccess(conn, fmt.Sprintf("Funding request accepted for %s into %s", username, address.Hex())); err != nil { 512 log.Warn("Failed to send funding success to client", "err", err) 513 return 514 } 515 select { 516 case f.update <- struct{}{}: 517 default: 518 } 519 } 520 } 521 522 // refresh attempts to retrieve the latest header from the chain and extract the 523 // associated faucet balance and nonce for connectivity caching. 524 func (f *faucet) refresh(head *types.Header) error { 525 // Ensure a state update does not run for too long 526 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) 527 defer cancel() 528 529 // If no header was specified, use the current chain head 530 var err error 531 if head == nil { 532 if head, err = f.client.HeaderByNumber(ctx, nil); err != nil { 533 return err 534 } 535 } 536 // Retrieve the balance, nonce and gas price from the current head 537 var ( 538 balance *big.Int 539 nonce uint64 540 price *big.Int 541 ) 542 if balance, err = f.client.BalanceAt(ctx, f.account.Address, head.Number); err != nil { 543 return err 544 } 545 if nonce, err = f.client.NonceAt(ctx, f.account.Address, head.Number); err != nil { 546 return err 547 } 548 if price, err = f.client.SuggestGasPrice(ctx); err != nil { 549 return err 550 } 551 // Everything succeeded, update the cached stats and eject old requests 552 f.lock.Lock() 553 f.head, f.balance = head, balance 554 f.price, f.nonce = price, nonce 555 for len(f.reqs) > 0 && f.reqs[0].Tx.Nonce() < f.nonce { 556 f.reqs = f.reqs[1:] 557 } 558 f.lock.Unlock() 559 560 return nil 561 } 562 563 // loop keeps waiting for interesting events and pushes them out to connected 564 // websockets. 565 func (f *faucet) loop() { 566 // Wait for chain events and push them to clients 567 heads := make(chan *types.Header, 16) 568 sub, err := f.client.SubscribeNewHead(context.Background(), heads) 569 if err != nil { 570 log.Crit("Failed to subscribe to head events", "err", err) 571 } 572 defer sub.Unsubscribe() 573 574 // Start a goroutine to update the state from head notifications in the background 575 update := make(chan *types.Header) 576 577 go func() { 578 for head := range update { 579 // New chain head arrived, query the current stats and stream to clients 580 timestamp := time.Unix(head.Time.Int64(), 0) 581 if time.Since(timestamp) > time.Hour { 582 log.Warn("Skipping faucet refresh, head too old", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp)) 583 continue 584 } 585 if err := f.refresh(head); err != nil { 586 log.Warn("Failed to update faucet state", "block", head.Number, "hash", head.Hash(), "err", err) 587 continue 588 } 589 // Faucet state retrieved, update locally and send to clients 590 f.lock.RLock() 591 log.Info("Updated faucet state", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp), "balance", f.balance, "nonce", f.nonce, "price", f.price) 592 593 balance := new(big.Int).Div(f.balance, ether) 594 peers := f.stack.Server().PeerCount() 595 596 for _, conn := range f.conns { 597 if err := send(conn, map[string]interface{}{ 598 "funds": balance, 599 "funded": f.nonce, 600 "peers": peers, 601 "requests": f.reqs, 602 }, time.Second); err != nil { 603 log.Warn("Failed to send stats to client", "err", err) 604 conn.Close() 605 continue 606 } 607 if err := send(conn, head, time.Second); err != nil { 608 log.Warn("Failed to send header to client", "err", err) 609 conn.Close() 610 } 611 } 612 f.lock.RUnlock() 613 } 614 }() 615 // Wait for various events and assing to the appropriate background threads 616 for { 617 select { 618 case head := <-heads: 619 // New head arrived, send if for state update if there's none running 620 select { 621 case update <- head: 622 default: 623 } 624 625 case <-f.update: 626 // Pending requests updated, stream to clients 627 f.lock.RLock() 628 for _, conn := range f.conns { 629 if err := send(conn, map[string]interface{}{"requests": f.reqs}, time.Second); err != nil { 630 log.Warn("Failed to send requests to client", "err", err) 631 conn.Close() 632 } 633 } 634 f.lock.RUnlock() 635 } 636 } 637 } 638 639 // sends transmits a data packet to the remote end of the websocket, but also 640 // setting a write deadline to prevent waiting forever on the node. 641 func send(conn *websocket.Conn, value interface{}, timeout time.Duration) error { 642 if timeout == 0 { 643 timeout = 60 * time.Second 644 } 645 conn.SetWriteDeadline(time.Now().Add(timeout)) 646 return websocket.JSON.Send(conn, value) 647 } 648 649 // sendError transmits an error to the remote end of the websocket, also setting 650 // the write deadline to 1 second to prevent waiting forever. 651 func sendError(conn *websocket.Conn, err error) error { 652 return send(conn, map[string]string{"error": err.Error()}, time.Second) 653 } 654 655 // sendSuccess transmits a success message to the remote end of the websocket, also 656 // setting the write deadline to 1 second to prevent waiting forever. 657 func sendSuccess(conn *websocket.Conn, msg string) error { 658 return send(conn, map[string]string{"success": msg}, time.Second) 659 } 660 661 // authTwitter tries to authenticate a faucet request using Twitter posts, returning 662 // the username, avatar URL and Ethereum address to fund on success. 663 func authTwitter(url string) (string, string, common.Address, error) { 664 // Ensure the user specified a meaningful URL, no fancy nonsense 665 parts := strings.Split(url, "/") 666 if len(parts) < 4 || parts[len(parts)-2] != "status" { 667 return "", "", common.Address{}, errors.New("Invalid Twitter status URL") 668 } 669 // Twitter's API isn't really friendly with direct links. Still, we don't 670 // want to do ask read permissions from users, so just load the public posts and 671 // scrape it for the Ethereum address and profile URL. 672 res, err := http.Get(url) 673 if err != nil { 674 return "", "", common.Address{}, err 675 } 676 defer res.Body.Close() 677 678 // Resolve the username from the final redirect, no intermediate junk 679 parts = strings.Split(res.Request.URL.String(), "/") 680 if len(parts) < 4 || parts[len(parts)-2] != "status" { 681 return "", "", common.Address{}, errors.New("Invalid Twitter status URL") 682 } 683 username := parts[len(parts)-3] 684 685 body, err := ioutil.ReadAll(res.Body) 686 if err != nil { 687 return "", "", common.Address{}, err 688 } 689 address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body))) 690 if address == (common.Address{}) { 691 return "", "", common.Address{}, errors.New("No Ethereum address found to fund") 692 } 693 var avatar string 694 if parts = regexp.MustCompile("src=\"([^\"]+twimg.com/profile_images[^\"]+)\"").FindStringSubmatch(string(body)); len(parts) == 2 { 695 avatar = parts[1] 696 } 697 return username + "@twitter", avatar, address, nil 698 } 699 700 // authGooglePlus tries to authenticate a faucet request using GooglePlus posts, 701 // returning the username, avatar URL and Ethereum address to fund on success. 702 func authGooglePlus(url string) (string, string, common.Address, error) { 703 // Ensure the user specified a meaningful URL, no fancy nonsense 704 parts := strings.Split(url, "/") 705 if len(parts) < 4 || parts[len(parts)-2] != "posts" { 706 return "", "", common.Address{}, errors.New("Invalid Google+ post URL") 707 } 708 username := parts[len(parts)-3] 709 710 // Google's API isn't really friendly with direct links. Still, we don't 711 // want to do ask read permissions from users, so just load the public posts and 712 // scrape it for the Ethereum address and profile URL. 713 res, err := http.Get(url) 714 if err != nil { 715 return "", "", common.Address{}, err 716 } 717 defer res.Body.Close() 718 719 body, err := ioutil.ReadAll(res.Body) 720 if err != nil { 721 return "", "", common.Address{}, err 722 } 723 address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body))) 724 if address == (common.Address{}) { 725 return "", "", common.Address{}, errors.New("No Ethereum address found to fund") 726 } 727 var avatar string 728 if parts = regexp.MustCompile("src=\"([^\"]+googleusercontent.com[^\"]+photo.jpg)\"").FindStringSubmatch(string(body)); len(parts) == 2 { 729 avatar = parts[1] 730 } 731 return username + "@google+", avatar, address, nil 732 } 733 734 // authFacebook tries to authenticate a faucet request using Facebook posts, 735 // returning the username, avatar URL and Ethereum address to fund on success. 736 func authFacebook(url string) (string, string, common.Address, error) { 737 // Ensure the user specified a meaningful URL, no fancy nonsense 738 parts := strings.Split(url, "/") 739 if len(parts) < 4 || parts[len(parts)-2] != "posts" { 740 return "", "", common.Address{}, errors.New("Invalid Facebook post URL") 741 } 742 username := parts[len(parts)-3] 743 744 // Facebook's Graph API isn't really friendly with direct links. Still, we don't 745 // want to do ask read permissions from users, so just load the public posts and 746 // scrape it for the Ethereum address and profile URL. 747 res, err := http.Get(url) 748 if err != nil { 749 return "", "", common.Address{}, err 750 } 751 defer res.Body.Close() 752 753 body, err := ioutil.ReadAll(res.Body) 754 if err != nil { 755 return "", "", common.Address{}, err 756 } 757 address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body))) 758 if address == (common.Address{}) { 759 return "", "", common.Address{}, errors.New("No Ethereum address found to fund") 760 } 761 var avatar string 762 if parts = regexp.MustCompile("src=\"([^\"]+fbcdn.net[^\"]+)\"").FindStringSubmatch(string(body)); len(parts) == 2 { 763 avatar = parts[1] 764 } 765 return username + "@facebook", avatar, address, nil 766 } 767 768 // authNoAuth tries to interpret a faucet request as a plain Ethereum address, 769 // without actually performing any remote authentication. This mode is prone to 770 // Byzantine attack, so only ever use for truly private networks. 771 func authNoAuth(url string) (string, string, common.Address, error) { 772 address := common.HexToAddress(regexp.MustCompile("0x[0-9a-fA-F]{40}").FindString(url)) 773 if address == (common.Address{}) { 774 return "", "", common.Address{}, errors.New("No Ethereum address found to fund") 775 } 776 return address.Hex() + "@noauth", "", address, nil 777 }