openethereum/rpc/src/v1/impls/signer.rs

273 lines
10 KiB
Rust
Raw Normal View History

// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity Ethereum.
// Parity 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.
// Parity 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 Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
//! Transactions Confirmations rpc implementation
use std::sync::Arc;
use ethereum_types::U256;
use ethkey;
use parity_runtime::Executor;
use parking_lot::Mutex;
use rlp::Rlp;
use types::transaction::{SignedTransaction, PendingTransaction};
2017-11-14 11:38:17 +01:00
use jsonrpc_core::{Result, BoxFuture, Error};
use jsonrpc_core::futures::{future, Future, IntoFuture};
use jsonrpc_core::futures::future::Either;
use jsonrpc_pubsub::{SubscriptionId, typed::{Sink, Subscriber}};
use v1::helpers::deprecated::{self, DeprecationNotice};
use v1::helpers::dispatch::{self, Dispatcher, WithToken, eth_data_hash};
use v1::helpers::{errors, ConfirmationPayload, FilledTransactionRequest, Subscribers};
use v1::helpers::external_signer::{SigningQueue, SignerService};
use v1::metadata::Metadata;
use v1::traits::Signer;
use v1::types::{TransactionModification, ConfirmationRequest, ConfirmationResponse, ConfirmationResponseWithToken, Bytes};
/// Transactions confirmation (personal) rpc implementation.
pub struct SignerClient<D: Dispatcher> {
signer: Arc<SignerService>,
accounts: Arc<dispatch::Accounts>,
dispatcher: D,
subscribers: Arc<Mutex<Subscribers<Sink<Vec<ConfirmationRequest>>>>>,
deprecation_notice: DeprecationNotice,
}
impl<D: Dispatcher + 'static> SignerClient<D> {
/// Create new instance of signer client.
pub fn new(
accounts: Arc<dispatch::Accounts>,
dispatcher: D,
signer: &Arc<SignerService>,
executor: Executor,
) -> Self {
let subscribers = Arc::new(Mutex::new(Subscribers::default()));
let subs = Arc::downgrade(&subscribers);
let s = Arc::downgrade(signer);
signer.queue().on_event(move |_event| {
if let (Some(s), Some(subs)) = (s.upgrade(), subs.upgrade()) {
let requests = s.requests().into_iter().map(Into::into).collect::<Vec<ConfirmationRequest>>();
for subscription in subs.lock().values() {
let subscription: &Sink<_> = subscription;
executor.spawn(subscription
2017-06-09 12:20:37 +02:00
.notify(Ok(requests.clone()))
.map(|_| ())
.map_err(|e| warn!(target: "rpc", "Unable to send notification: {}", e))
);
}
}
});
SignerClient {
signer: signer.clone(),
accounts: accounts.clone(),
dispatcher,
subscribers,
deprecation_notice: Default::default(),
}
}
2017-11-14 11:38:17 +01:00
fn confirm_internal<F, T>(&self, id: U256, modification: TransactionModification, f: F) -> BoxFuture<WithToken<ConfirmationResponse>> where
F: FnOnce(D, &Arc<dispatch::Accounts>, ConfirmationPayload) -> T,
T: IntoFuture<Item=WithToken<ConfirmationResponse>, Error=Error>,
T::Future: Send + 'static
2016-11-30 16:11:41 +01:00
{
let dispatcher = self.dispatcher.clone();
let signer = self.signer.clone();
Box::new(signer.take(&id).map(|sender| {
let mut payload = sender.request.payload.clone();
// Modify payload
if let ConfirmationPayload::SendTransaction(ref mut request) = payload {
if let Some(sender) = modification.sender {
request.from = sender;
// Altering sender should always reset the nonce.
request.nonce = None;
}
if let Some(gas_price) = modification.gas_price {
request.gas_price = gas_price;
}
if let Some(gas) = modification.gas {
request.gas = gas;
}
if let Some(ref condition) = modification.condition {
request.condition = condition.clone().map(Into::into);
2016-12-15 18:19:19 +01:00
}
}
let fut = f(dispatcher, &self.accounts, payload);
Either::A(fut.into_future().then(move |result| {
// Execute
if let Ok(ref response) = result {
signer.request_confirmed(sender, Ok((*response).clone()));
} else {
signer.request_untouched(sender);
}
result
}))
})
.unwrap_or_else(|| Either::B(future::err(errors::invalid_params("Unknown RequestID", id)))))
}
2017-11-14 11:38:17 +01:00
fn verify_transaction<F>(bytes: Bytes, request: FilledTransactionRequest, process: F) -> Result<ConfirmationResponse> where
F: FnOnce(PendingTransaction) -> Result<ConfirmationResponse>,
{
let signed_transaction = Rlp::new(&bytes.0).as_val().map_err(errors::rlp)?;
let signed_transaction = SignedTransaction::new(signed_transaction).map_err(|e| errors::invalid_params("Invalid signature.", e))?;
let sender = signed_transaction.sender();
// Verification
let sender_matches = sender == request.from;
let data_matches = signed_transaction.data == request.data;
let value_matches = signed_transaction.value == request.value;
let nonce_matches = match request.nonce {
Some(nonce) => signed_transaction.nonce == nonce,
None => true,
};
// Dispatch if everything is ok
if sender_matches && data_matches && value_matches && nonce_matches {
let pending_transaction = PendingTransaction::new(signed_transaction, request.condition.map(Into::into));
process(pending_transaction)
} else {
let mut error = Vec::new();
if !sender_matches { error.push("from") }
if !data_matches { error.push("data") }
if !value_matches { error.push("value") }
if !nonce_matches { error.push("nonce") }
Err(errors::invalid_params("Sent transaction does not match the request.", error))
}
}
2016-11-30 16:11:41 +01:00
}
impl<D: Dispatcher + 'static> Signer for SignerClient<D> {
type Metadata = Metadata;
2016-11-30 16:11:41 +01:00
2017-11-14 11:38:17 +01:00
fn requests_to_confirm(&self) -> Result<Vec<ConfirmationRequest>> {
self.deprecation_notice.print("signer_requestsToConfirm", deprecated::msgs::ACCOUNTS);
Ok(self.signer.requests()
2016-11-30 16:11:41 +01:00
.into_iter()
.map(Into::into)
.collect()
)
}
// TODO [ToDr] TransactionModification is redundant for some calls
// might be better to replace it in future
fn confirm_request(&self, id: U256, modification: TransactionModification, pass: String)
2017-11-14 11:38:17 +01:00
-> BoxFuture<ConfirmationResponse>
{
self.deprecation_notice.print("signer_confirmRequest", deprecated::msgs::ACCOUNTS);
Box::new(self.confirm_internal(id, modification, move |dis, accounts, payload| {
dispatch::execute(dis, accounts, payload, dispatch::SignWith::Password(pass.into()))
}).map(dispatch::WithToken::into_value))
2016-11-30 16:11:41 +01:00
}
fn confirm_request_with_token(&self, id: U256, modification: TransactionModification, token: String)
2017-11-14 11:38:17 +01:00
-> BoxFuture<ConfirmationResponseWithToken>
{
self.deprecation_notice.print("signer_confirmRequestWithToken", deprecated::msgs::ACCOUNTS);
Box::new(self.confirm_internal(id, modification, move |dis, accounts, payload| {
dispatch::execute(dis, accounts, payload, dispatch::SignWith::Token(token.into()))
2016-11-30 17:05:31 +01:00
}).and_then(|v| match v {
WithToken::No(_) => Err(errors::internal("Unexpected response without token.", "")),
WithToken::Yes(response, token) => Ok(ConfirmationResponseWithToken {
result: response,
token,
2016-11-30 17:05:31 +01:00
}),
}))
2016-11-30 16:11:41 +01:00
}
2017-11-14 11:38:17 +01:00
fn confirm_request_raw(&self, id: U256, bytes: Bytes) -> Result<ConfirmationResponse> {
self.deprecation_notice.print("signer_confirmRequestRaw", deprecated::msgs::ACCOUNTS);
self.signer.take(&id).map(|sender| {
let payload = sender.request.payload.clone();
let result = match payload {
ConfirmationPayload::SendTransaction(request) => {
Self::verify_transaction(bytes, request, |pending_transaction| {
self.dispatcher.dispatch_transaction(pending_transaction)
.map(Into::into)
.map(ConfirmationResponse::SendTransaction)
})
},
ConfirmationPayload::SignTransaction(request) => {
Self::verify_transaction(bytes, request, |pending_transaction| {
let rich = self.dispatcher.enrich(pending_transaction.transaction);
Ok(ConfirmationResponse::SignTransaction(rich))
})
},
ConfirmationPayload::EthSignMessage(address, data) => {
let expected_hash = eth_data_hash(data);
2017-05-11 12:18:20 +02:00
let signature = ethkey::Signature::from_electrum(&bytes.0);
match ethkey::verify_address(&address, &signature, &expected_hash) {
Ok(true) => Ok(ConfirmationResponse::Signature(bytes.0.as_slice().into())),
Ok(false) => Err(errors::invalid_params("Sender address does not match the signature.", ())),
Err(err) => Err(errors::invalid_params("Invalid signature received.", err)),
}
},
ConfirmationPayload::SignMessage(address, hash) => {
let signature = ethkey::Signature::from_electrum(&bytes.0);
match ethkey::verify_address(&address, &signature, &hash) {
Ok(true) => Ok(ConfirmationResponse::Signature(bytes.0.as_slice().into())),
Ok(false) => Err(errors::invalid_params("Sender address does not match the signature.", ())),
Err(err) => Err(errors::invalid_params("Invalid signature received.", err)),
}
},
ConfirmationPayload::Decrypt(_address, _data) => {
// TODO [ToDr]: Decrypt can we verify if the answer is correct?
Ok(ConfirmationResponse::Decrypt(bytes))
},
};
if let Ok(ref response) = result {
self.signer.request_confirmed(sender, Ok(response.clone()));
} else {
self.signer.request_untouched(sender);
}
result
}).unwrap_or_else(|| Err(errors::invalid_params("Unknown RequestID", id)))
}
2017-11-14 11:38:17 +01:00
fn reject_request(&self, id: U256) -> Result<bool> {
self.deprecation_notice.print("signer_rejectRequest", deprecated::msgs::ACCOUNTS);
let res = self.signer.take(&id).map(|sender| self.signer.request_rejected(sender));
2016-10-31 17:11:56 +01:00
Ok(res.is_some())
}
2017-11-14 11:38:17 +01:00
fn generate_token(&self) -> Result<String> {
self.deprecation_notice.print("signer_generateAuthorizationToken", deprecated::msgs::ACCOUNTS);
self.signer.generate_token()
.map_err(errors::token)
}
fn subscribe_pending(&self, _meta: Self::Metadata, sub: Subscriber<Vec<ConfirmationRequest>>) {
self.deprecation_notice.print("signer_subscribePending", deprecated::msgs::ACCOUNTS);
self.subscribers.lock().push(sub)
}
fn unsubscribe_pending(&self, _: Option<Self::Metadata>, id: SubscriptionId) -> Result<bool> {
let res = self.subscribers.lock().remove(&id).is_some();
Ok(res)
}
}