// Copyright 2018 The go-ethereum Authors // This file is part of go-ethereum. // // go-ethereum is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // go-ethereum 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 General Public License for more details. // // You should have received a copy of the GNU General Public License // along with go-ethereum. If not, see . package core import ( "bufio" "fmt" "os" "strings" "sync" "github.com/davecgh/go-spew/spew" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/log" "golang.org/x/crypto/ssh/terminal" ) type CommandlineUI struct { in *bufio.Reader mu sync.Mutex } func NewCommandlineUI() *CommandlineUI { return &CommandlineUI{in: bufio.NewReader(os.Stdin)} } // readString reads a single line from stdin, trimming if from spaces, enforcing // non-emptyness. func (ui *CommandlineUI) readString() string { for { fmt.Printf("> ") text, err := ui.in.ReadString('\n') if err != nil { log.Crit("Failed to read user input", "err", err) } if text = strings.TrimSpace(text); text != "" { return text } } } // readPassword reads a single line from stdin, trimming it from the trailing new // line and returns it. The input will not be echoed. func (ui *CommandlineUI) readPassword() string { fmt.Printf("Enter password to approve:\n") fmt.Printf("> ") text, err := terminal.ReadPassword(int(os.Stdin.Fd())) if err != nil { log.Crit("Failed to read password", "err", err) } fmt.Println() fmt.Println("-----------------------") return string(text) } // readPassword reads a single line from stdin, trimming it from the trailing new // line and returns it. The input will not be echoed. func (ui *CommandlineUI) readPasswordText(inputstring string) string { fmt.Printf("Enter %s:\n", inputstring) fmt.Printf("> ") text, err := terminal.ReadPassword(int(os.Stdin.Fd())) if err != nil { log.Crit("Failed to read password", "err", err) } fmt.Println("-----------------------") return string(text) } func (ui *CommandlineUI) OnInputRequired(info UserInputRequest) (UserInputResponse, error) { fmt.Println(info.Title) fmt.Println(info.Prompt) if info.IsPassword { text, err := terminal.ReadPassword(int(os.Stdin.Fd())) if err != nil { log.Error("Failed to read password", "err", err) } fmt.Println("-----------------------") return UserInputResponse{string(text)}, err } text := ui.readString() fmt.Println("-----------------------") return UserInputResponse{text}, nil } // confirm returns true if user enters 'Yes', otherwise false func (ui *CommandlineUI) confirm() bool { fmt.Printf("Approve? [y/N]:\n") if ui.readString() == "y" { return true } fmt.Println("-----------------------") return false } func showMetadata(metadata Metadata) { fmt.Printf("Request context:\n\t%v -> %v -> %v\n", metadata.Remote, metadata.Scheme, metadata.Local) fmt.Printf("\nAdditional HTTP header data, provided by the external caller:\n") fmt.Printf("\tUser-Agent: %v\n\tOrigin: %v\n", metadata.UserAgent, metadata.Origin) } // ApproveTx prompt the user for confirmation to request to sign Transaction func (ui *CommandlineUI) ApproveTx(request *SignTxRequest) (SignTxResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() weival := request.Transaction.Value.ToInt() fmt.Printf("--------- Transaction request-------------\n") if to := request.Transaction.To; to != nil { fmt.Printf("to: %v\n", to.Original()) if !to.ValidChecksum() { fmt.Printf("\nWARNING: Invalid checksum on to-address!\n\n") } } else { fmt.Printf("to: \n") } fmt.Printf("from: %v\n", request.Transaction.From.String()) fmt.Printf("value: %v wei\n", weival) fmt.Printf("gas: %v (%v)\n", request.Transaction.Gas, uint64(request.Transaction.Gas)) fmt.Printf("gasprice: %v wei\n", request.Transaction.GasPrice.ToInt()) fmt.Printf("nonce: %v (%v)\n", request.Transaction.Nonce, uint64(request.Transaction.Nonce)) if request.Transaction.Data != nil { d := *request.Transaction.Data if len(d) > 0 { fmt.Printf("data: %v\n", hexutil.Encode(d)) } } if request.Callinfo != nil { fmt.Printf("\nTransaction validation:\n") for _, m := range request.Callinfo { fmt.Printf(" * %s : %s\n", m.Typ, m.Message) } fmt.Println() } fmt.Printf("\n") showMetadata(request.Meta) fmt.Printf("-------------------------------------------\n") if !ui.confirm() { return SignTxResponse{request.Transaction, false, ""}, nil } return SignTxResponse{request.Transaction, true, ui.readPassword()}, nil } // ApproveSignData prompt the user for confirmation to request to sign data func (ui *CommandlineUI) ApproveSignData(request *SignDataRequest) (SignDataResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() fmt.Printf("-------- Sign data request--------------\n") fmt.Printf("Account: %s\n", request.Address.String()) fmt.Printf("message:\n") for _, nvt := range request.Message { fmt.Printf("%v\n", nvt.Pprint(1)) } //fmt.Printf("message: \n%v\n", request.Message) fmt.Printf("raw data: \n%q\n", request.Rawdata) fmt.Printf("message hash: %v\n", request.Hash) fmt.Printf("-------------------------------------------\n") showMetadata(request.Meta) if !ui.confirm() { return SignDataResponse{false, ""}, nil } return SignDataResponse{true, ui.readPassword()}, nil } // ApproveExport prompt the user for confirmation to export encrypted Account json func (ui *CommandlineUI) ApproveExport(request *ExportRequest) (ExportResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() fmt.Printf("-------- Export Account request--------------\n") fmt.Printf("A request has been made to export the (encrypted) keyfile\n") fmt.Printf("Approving this operation means that the caller obtains the (encrypted) contents\n") fmt.Printf("\n") fmt.Printf("Account: %x\n", request.Address) //fmt.Printf("keyfile: \n%v\n", request.file) fmt.Printf("-------------------------------------------\n") showMetadata(request.Meta) return ExportResponse{ui.confirm()}, nil } // ApproveImport prompt the user for confirmation to import Account json func (ui *CommandlineUI) ApproveImport(request *ImportRequest) (ImportResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() fmt.Printf("-------- Import Account request--------------\n") fmt.Printf("A request has been made to import an encrypted keyfile\n") fmt.Printf("-------------------------------------------\n") showMetadata(request.Meta) if !ui.confirm() { return ImportResponse{false, "", ""}, nil } return ImportResponse{true, ui.readPasswordText("Old password"), ui.readPasswordText("New password")}, nil } // ApproveListing prompt the user for confirmation to list accounts // the list of accounts to list can be modified by the UI func (ui *CommandlineUI) ApproveListing(request *ListRequest) (ListResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() fmt.Printf("-------- List Account request--------------\n") fmt.Printf("A request has been made to list all accounts. \n") fmt.Printf("You can select which accounts the caller can see\n") for _, account := range request.Accounts { fmt.Printf(" [x] %v\n", account.Address.Hex()) fmt.Printf(" URL: %v\n", account.URL) fmt.Printf(" Type: %v\n", account.Typ) } fmt.Printf("-------------------------------------------\n") showMetadata(request.Meta) if !ui.confirm() { return ListResponse{nil}, nil } return ListResponse{request.Accounts}, nil } // ApproveNewAccount prompt the user for confirmation to create new Account, and reveal to caller func (ui *CommandlineUI) ApproveNewAccount(request *NewAccountRequest) (NewAccountResponse, error) { ui.mu.Lock() defer ui.mu.Unlock() fmt.Printf("-------- New Account request--------------\n\n") fmt.Printf("A request has been made to create a new account. \n") fmt.Printf("Approving this operation means that a new account is created,\n") fmt.Printf("and the address is returned to the external caller\n\n") showMetadata(request.Meta) if !ui.confirm() { return NewAccountResponse{false, ""}, nil } return NewAccountResponse{true, ui.readPassword()}, nil } // ShowError displays error message to user func (ui *CommandlineUI) ShowError(message string) { fmt.Printf("-------- Error message from Clef-----------\n") fmt.Println(message) fmt.Printf("-------------------------------------------\n") } // ShowInfo displays info message to user func (ui *CommandlineUI) ShowInfo(message string) { fmt.Printf("Info: %v\n", message) } func (ui *CommandlineUI) OnApprovedTx(tx ethapi.SignTransactionResult) { fmt.Printf("Transaction signed:\n ") spew.Dump(tx.Tx) } func (ui *CommandlineUI) OnSignerStartup(info StartupInfo) { fmt.Printf("------- Signer info -------\n") for k, v := range info.Info { fmt.Printf("* %v : %v\n", k, v) } }