Add input validation for fee rates, addresses, connections, and contract sizes

Author: kwsantiago

ddk-node/src/command.rs

@@ -142,6 +142,12 @@ pub async fn cli_command(
                 amount,
                 fee_rate,
             } => {
+                if fee_rate > 1000 {
+                    return Err(anyhow!(
+                        "Fee rate too high: {} sat/vbyte (max: 1000)",
+                        fee_rate
+                    ));
+                }
                 let txid = client
                     .send(SendRequest {
                         address,
@@ -237,7 +243,12 @@ pub async fn cli_command(
             print!("{peers}");
         }
         CliCommand::Connect { connect_string } => {
-            let parts = connect_string.split("@").collect::<Vec<&str>>();
+            let parts: Vec<&str> = connect_string.split('@').collect();
+            if parts.len() != 2 {
+                return Err(anyhow!(
+                    "Invalid connection string format. Expected: pubkey@host:port"
+                ));
+            }
             client
                 .connect_peer(ConnectRequest {
                     pubkey: parts[0].to_string(),
@@ -330,6 +341,12 @@ async fn interactive_contract_input(
                 .prompt()?
                 .parse()?;
             let fee_rate: u64 = Text::new("Fee rate (sats/vbyte):").prompt()?.parse()?;
+            if fee_rate > 1000 {
+                return Err(anyhow!(
+                    "Fee rate too high: {} sat/vbyte (max: 1000)",
+                    fee_rate
+                ));
+            }
             let min_price: u64 = Text::new("Minimum Bitcoin price:").prompt()?.parse()?;
             let max_price: u64 = Text::new("Maximum Bitcoin price:").prompt()?.parse()?;
             let num_steps: u64 = Text::new("Number of rounding steps:").prompt()?.parse()?;
@@ -372,6 +389,12 @@ async fn interactive_contract_input(
                 outcome_payouts.push(outcome_payout);
             }
             let fee_rate: u64 = Text::new("Fee rate (sats/vbyte):").prompt()?.parse()?;
+            if fee_rate > 1000 {
+                return Err(anyhow!(
+                    "Fee rate too high: {} sat/vbyte (max: 1000)",
+                    fee_rate
+                ));
+            }
             // TODO: list possible events.
             ddk_payouts::enumeration::create_contract_input(
                 outcome_payouts,

ddk-node/src/lib.rs

@@ -143,8 +143,31 @@ impl DdkRpc for DdkNode {
             contract_input,
             counter_party,
         } = request.into_inner();
+
+        if contract_input.len() > 1_000_000 {
+            return Err(Status::new(
+                Code::InvalidArgument,
+                "Contract input too large (max: 1MB)",
+            ));
+        }
+
         let contract_input: ContractInput =
-            serde_json::from_slice(&contract_input).expect("couldn't get bytes correct");
+            serde_json::from_slice(&contract_input).map_err(|e| {
+                Status::new(
+                    Code::InvalidArgument,
+                    format!("Invalid contract input: {}", e),
+                )
+            })?;
+
+        if contract_input.fee_rate > 1000 {
+            return Err(Status::new(
+                Code::InvalidArgument,
+                format!(
+                    "Fee rate too high: {} sat/vbyte (max: 1000)",
+                    contract_input.fee_rate
+                ),
+            ));
+        }
         let mut oracle_announcements = Vec::new();
         for info in &contract_input.contract_infos {
             let announcement = self
@@ -297,7 +320,16 @@ impl DdkRpc for DdkNode {
         request: Request<ConnectRequest>,
     ) -> Result<Response<ConnectResponse>, Status> {
         let ConnectRequest { pubkey, host } = request.into_inner();
-        let pubkey = PublicKey::from_str(&pubkey).unwrap();
+
+        if host.len() > 255 {
+            return Err(Status::new(
+                Code::InvalidArgument,
+                "Host string too long (max: 255 characters)",
+            ));
+        }
+
+        let pubkey = PublicKey::from_str(&pubkey)
+            .map_err(|e| Status::new(Code::InvalidArgument, format!("Invalid pubkey: {}", e)))?;
         self.node.transport.connect_outbound(pubkey, &host).await;
         Ok(Response::new(ConnectResponse {}))
     }
@@ -336,7 +368,17 @@ impl DdkRpc for DdkNode {
             amount,
             fee_rate,
         } = request.into_inner();
-        let address = Address::from_str(&address).unwrap().assume_checked();
+
+        if fee_rate > 1000 {
+            return Err(Status::new(
+                Code::InvalidArgument,
+                format!("Fee rate too high: {} sat/vbyte (max: 1000)", fee_rate),
+            ));
+        }
+
+        let address = Address::from_str(&address)
+            .map_err(|e| Status::new(Code::InvalidArgument, format!("Invalid address: {}", e)))?
+            .assume_checked();
         let amount = Amount::from_sat(amount);
         let fee_rate = match FeeRate::from_sat_per_vb(fee_rate) {
             Some(f) => f,