Block parcels with invalid custom actions

Author: Joon-Mo Yang

core/src/client/client.rs

@@ -22,7 +22,10 @@ use std::time::Instant;
 use cio::IoChannel;
 use ckey::{Address, Public};
 use cnetwork::NodeId;
-use cstate::{Asset, AssetAddress, AssetScheme, AssetSchemeAddress, StateDB, TopLevelState, TopStateInfo};
+use cstate::{
+    ActionHandler, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, StateDB, TopBackend, TopLevelState,
+    TopStateInfo,
+};
 use ctypes::invoice::ParcelInvoice;
 use ctypes::parcel::ChangeShard;
 use ctypes::transaction::Transaction;
@@ -449,6 +452,10 @@ impl BlockChainClient for Client {
             })
         })
     }
+
+    fn custom_handlers(&self) -> Vec<Arc<ActionHandler>> {
+        self.state_db.read().custom_handlers().to_vec()
+    }
 }
 
 pub struct Importer {

core/src/client/mod.rs

@@ -31,7 +31,7 @@ use std::sync::Arc;
 
 use ckey::{Address, Public};
 use cnetwork::NodeId;
-use cstate::{Asset, AssetScheme, AssetSchemeAddress, TopStateInfo};
+use cstate::{ActionHandler, Asset, AssetScheme, AssetSchemeAddress, TopStateInfo};
 use ctypes::invoice::{Invoice, ParcelInvoice};
 use ctypes::parcel::ChangeShard;
 use ctypes::transaction::Transaction;
@@ -209,6 +209,8 @@ pub trait BlockChainClient: Sync + Send + AccountData + BlockChain + ImportBlock
     fn parcel_invoice(&self, id: ParcelId) -> Option<ParcelInvoice>;
 
     fn transaction_invoice(&self, id: TransactionId) -> Option<Invoice>;
+
+    fn custom_handlers(&self) -> Vec<Arc<ActionHandler>>;
 }
 
 /// Result of import block operation.

core/src/client/test_client.rs

@@ -38,7 +38,7 @@ use std::sync::Arc;
 use ckey::{Address, Generator, Random};
 use cmerkle::skewed_merkle_root;
 use cnetwork::NodeId;
-use cstate::StateDB;
+use cstate::{ActionHandler, StateDB};
 use ctypes::invoice::ParcelInvoice;
 use ctypes::parcel::{Action, Parcel};
 use ctypes::BlockNumber;
@@ -508,6 +508,10 @@ impl BlockChainClient for TestBlockChainClient {
     fn transaction_invoice(&self, _id: TransactionId) -> Option<Invoice> {
         unimplemented!()
     }
+
+    fn custom_handlers(&self) -> Vec<Arc<ActionHandler>> {
+        unimplemented!()
+    }
 }
 
 impl super::EngineClient for TestBlockChainClient {

rpc/src/v1/impls/chain.rs

@@ -18,15 +18,16 @@ use std::sync::Arc;
 
 use ccore::{
     AssetClient, BlockId, ExecuteClient, MinerService, MiningBlockChainClient, RegularKey, Shard, SignedParcel,
+    UnverifiedParcel,
 };
 use ckey::{Address, Public};
 use cstate::{Asset, AssetScheme, AssetSchemeAddress};
 use ctypes::invoice::{Invoice, ParcelInvoice};
-use ctypes::parcel::ChangeShard;
+use ctypes::parcel::{Action, ChangeShard};
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
 use primitives::{H160, H256, U256};
-use rlp::UntrustedRlp;
+use rlp::{DecoderError, UntrustedRlp};
 
 use jsonrpc_core::Result;
 
@@ -64,6 +65,17 @@ where
         UntrustedRlp::new(&raw.into_vec())
             .as_val()
             .map_err(errors::rlp)
+            .and_then(|parcel: UnverifiedParcel| {
+                match &parcel.as_unsigned().action {
+                    Action::Custom(bytes) => {
+                        if !self.client.custom_handlers().iter().any(|c| c.is_target(bytes)) {
+                            return Err(errors::rlp(DecoderError::Custom("Invalid custom action!")))
+                        }
+                    }
+                    _ => {}
+                }
+                Ok(parcel)
+            })
             .and_then(|parcel| SignedParcel::new(parcel).map_err(errors::parcel_core))
             .and_then(|signed| {
                 let hash = signed.hash();

sync/src/block/extension.rs

@@ -21,9 +21,11 @@ use std::sync::Arc;
 
 use ccore::encoded::Header as EncodedHeader;
 use ccore::{
-    Block, BlockChainClient, BlockId, BlockImportError, ChainNotify, Header, ImportError, Seal, UnverifiedParcel,
+    Block, BlockChainClient, BlockId, BlockImportError, BlockInfo, ChainInfo, ChainNotify, Client, Header, ImportBlock,
+    ImportError, Seal, UnverifiedParcel,
 };
 use cnetwork::{Api, NetworkExtension, NodeId, TimerToken};
+use ctypes::parcel::Action;
 use ctypes::BlockNumber;
 use primitives::{H256, U256};
 use rlp::{Encodable, UntrustedRlp};
@@ -41,13 +43,13 @@ pub struct Extension {
     requests: RwLock<HashMap<NodeId, Vec<(u64, RequestMessage)>>>,
     header_downloaders: RwLock<HashMap<NodeId, HeaderDownloader>>,
     body_downloader: Mutex<BodyDownloader>,
-    client: Arc<BlockChainClient>,
+    client: Arc<Client>,
     api: Mutex<Option<Arc<Api>>>,
     last_request: AtomicUsize,
 }
 
 impl Extension {
-    pub fn new(client: Arc<BlockChainClient>) -> Arc<Self> {
+    pub fn new(client: Arc<Client>) -> Arc<Self> {
         Arc::new(Self {
             requests: RwLock::new(HashMap::new()),
             header_downloaders: RwLock::new(HashMap::new()),
@@ -394,7 +396,20 @@ impl Extension {
 
                 headers.first().map(|header| header.number()) == Some(*start_number)
             }
-            (RequestMessage::Bodies(..), ResponseMessage::Bodies(..)) => true,
+            (RequestMessage::Bodies(_), ResponseMessage::Bodies(bodies)) => {
+                for body in bodies {
+                    for parcel in body {
+                        let is_valid = match &parcel.as_unsigned().action {
+                            Action::Custom(bytes) => self.client.custom_handlers().iter().any(|c| c.is_target(bytes)),
+                            _ => true,
+                        };
+                        if !is_valid {
+                            return false
+                        }
+                    }
+                }
+                true
+            }
             (RequestMessage::StateHead(..), ResponseMessage::StateHead(..)) => unimplemented!(),
             (
                 RequestMessage::StateChunk {