dpos共识算法，基于以太坊的修改的go版本.zip

Clef ---- Clef can be used to sign transactions and data and is meant as a replacement for geth's account management. This allows DApps not to depend on geth's account management. When a DApp wants to sign data it can send the data to the signer, the signer will then provide the user with context and asks the user for permission to sign the data. If the users grants the signing request the signer will send the signature back to the DApp. This setup allows a DApp to connect to a remote Ethereum node and send transactions that are locally signed. This can help in situations when a DApp is connected to a remote node because a local Ethereum node is not available, not synchronised with the chain or a particular Ethereum node that has no built-in (or limited) account management. Clef can run as a daemon on the same machine, or off a usb-stick like [usb armory](https://inversepath.com/usbarmory), or a separate VM in a [QubesOS](https://www.qubes-os.org/) type os setup. Check out * the [tutorial](tutorial.md) for some concrete examples on how the signer works. * the [setup docs](docs/setup.md) for some information on how to configure it to work on QubesOS or USBArmory. ## Command line flags Clef accepts the following command line options: ``` COMMANDS: init Initialize the signer, generate secret storage attest Attest that a js-file is to be used addpw Store a credential for a keystore file help Shows a list of commands or help for one command GLOBAL OPTIONS: --loglevel value log level to emit to the screen (default: 4) --keystore value Directory for the keystore (default: "$HOME/.ethereum/keystore") --configdir value Directory for clef configuration (default: "$HOME/.clef") --networkid value Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby) (default: 1) --lightkdf Reduce key-derivation RAM & CPU usage at some expense of KDF strength --nousb Disables monitoring for and managing USB hardware wallets --rpcaddr value HTTP-RPC server listening interface (default: "localhost") --rpcport value HTTP-RPC server listening port (default: 8550) --signersecret value A file containing the password used to encrypt signer credentials, e.g. keystore credentials and ruleset hash --4bytedb value File containing 4byte-identifiers (default: "./4byte.json") --4bytedb-custom value File used for writing new 4byte-identifiers submitted via API (default: "./4byte-custom.json") --auditlog value File used to emit audit logs. Set to "" to disable (default: "audit.log") --rules value Enable rule-engine (default: "rules.json") --stdio-ui Use STDIN/STDOUT as a channel for an external UI. This means that an STDIN/STDOUT is used for RPC-communication with a e.g. a graphical user interface, and can be used when the signer is started by an external process. --stdio-ui-test Mechanism to test interface between signer and UI. Requires 'stdio-ui'. --help, -h show help --version, -v print the version ``` Example: ``` signer -keystore /my/keystore -chainid 4 ``` ## Security model The security model of the signer is as follows: * One critical component (the signer binary / daemon) is responsible for handling cryptographic operations: signing, private keys, encryption/decryption of keystore files. * The signer binary has a well-defined 'external' API. * The 'external' API is considered UNTRUSTED. * The signer binary also communicates with whatever process that invoked the binary, via stdin/stdout. * This channel is considered 'trusted'. Over this channel, approvals and passwords are communicated. The general flow for signing a transaction using e.g. geth is as follows:  In this case, `geth` would be started with `--externalsigner=http://localhost:8550` and would relay requests to `eth.sendTransaction`. ## TODOs Some snags and todos * [ ] The signer should take a startup param "--no-change", for UIs that do not contain the capability to perform changes to things, only approve/deny. Such a UI should be able to start the signer in a more secure mode by telling it that it only wants approve/deny capabilities. * [x] It would be nice if the signer could collect new 4byte-id:s/method selectors, and have a secondary database for those (`4byte_custom.json`). Users could then (optionally) submit their collections for inclusion upstream. * It should be possible to configure the signer to check if an account is indeed known to it, before passing on to the UI. The reason it currently does not, is that it would make it possible to enumerate accounts if it immediately returned "unknown account". * [x] It should be possible to configure the signer to auto-allow listing (certain) accounts, instead of asking every time. * [x] Done Upon startup, the signer should spit out some info to the caller (particularly important when executed in `stdio-ui`-mode), invoking methods with the following info: * [x] Version info about the signer * [x] Address of API (http/ipc) * [ ] List of known accounts * [ ] Have a default timeout on signing operations, so that if the user has not answered withing e.g. 60 seconds, the request is rejected. * [ ] `account_signRawTransaction` * [ ] `account_bulkSignTransactions([] transactions)` should * only exist if enabled via config/flag * only allow non-data-sending transactions * all txs must use the same `from`-account * let the user confirm, showing * the total amount * the number of unique recipients * Geth todos - The signer should pass the `Origin` header as call-info to the UI. As of right now, the way that info about the request is put together is a bit of a hack into the http server. This could probably be greatly improved - Relay: Geth should be started in `geth --external_signer localhost:8550`. - Currently, the Geth APIs use `common.Address` in the arguments to transaction submission (e.g `to` field). This type is 20 `bytes`, and is incapable of carrying checksum information. The signer uses `common.MixedcaseAddress`, which retains the original input. - The Geth api should switch to use the same type, and relay `to`-account verbatim to the external api. * [x] Storage * [x] An encrypted key-value storage should be implemented * See [rules.md](rules.md) for more info about this. * Another potential thing to introduce is pairing. * To prevent spurious requests which users just accept, implement a way to "pair" the caller with the signer (external API). * Thus geth/mist/cpp would cryptographically handshake and afterwards the caller would be allowed to make signing requests. * This feature would make the addition of rules less dangerous. * Wallets / accounts. Add API methods for wallets. ## Communication ### External API The signer listens to HTTP requests on `rpcaddr`:`rpcport`, with the same JSONRPC standard as Geth. The messages are expected to be JSON [jsonrpc 2.0 standard](http://www.jsonrpc.org/specification). Some of these call can require user interaction. Clients must be aware that responses may be delayed significanlty or may never be received if a users decides to ignore the confirmation request. The External API is **untrusted** : it does not accept credentials over this api, nor does it expect that requests have any authority. ### UI API The signer has one native console-based UI, for operation without any standalone tools. However, there is also an API to communicate with an external UI. To enable that UI, the signer needs to be executed with the `--stdio-ui` option, which allocates the `stdin`/`stdout` for the UI-api. An example (insecure) proof-of-concept of has been implemented in `pythonsigner.py`. The model is as follows: * The user starts the UI app (`pythonsigner.py`). * The UI app starts