Merge pull request #9 from yangby-cryptape/feature/testing-contract-security

feat: let the contract which for testing purpose only more security

Author: chaoticlonghair

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "can-update-without-ownership-lock"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Boyu Yang <[email protected]>"]
 edition = "2021"
 license = "MIT"
@@ -10,3 +10,4 @@ repository = "https://github.com/ckb-cell/ckb-bitcoin-spv-contracts"
 
 [dependencies]
 ckb-std = "0.15.1"
+ckb-hash = { version = "0.112.1", default-features = false, features = ["ckb-contract"] }

contracts/can-update-without-ownership-lock/Cargo.toml

@@ -17,8 +17,11 @@ them.
 
 It will return success when any follow condition is satisfied:
 
-- the witness for this lock script is reverse of the `args` in it.
+- the `args` for this lock script is the result of calling
+  [`ckb_hash::blake2b_256`] on the `witness` of it.
 
 - there is no witness for this lock script, but total capacity of cells
   which use this lock script are not greater than total capacity of cells
   which use this lock script after this transaction.
+
+[`ckb_hash::blake2b_256`]: https://docs.rs/ckb-hash/0.112.1/ckb_hash/fn.blake2b_256.html

contracts/can-update-without-ownership-lock/README.md

@@ -1,5 +1,6 @@
 use alloc::vec::Vec;
 
+use ckb_hash::blake2b_256;
 #[cfg(debug_assertions)]
 use ckb_std::ckb_types::prelude::*;
 use ckb_std::{ckb_constants::Source, debug, high_level as hl};
@@ -12,7 +13,7 @@ pub fn main() -> Result<()> {
     let script_hash = hl::load_script_hash()?;
     debug!("script hash = {:#x}", script_hash.pack());
     let args = hl::load_script()?.args();
-    let expected_witness = args.raw_data().iter().cloned().rev().collect::<Vec<u8>>();
+    let expected_proof = args.raw_data().iter().cloned().collect::<Vec<u8>>();
 
     let mut checked = false;
 
@@ -34,12 +35,13 @@ pub fn main() -> Result<()> {
 
         if let Ok(witness_args) = hl::load_witness_args(index, Source::Input) {
             if let Some(lock_witness) = witness_args.lock().to_opt() {
-                if lock_witness.raw_data().as_ref() == expected_witness {
+                let actual_proof = blake2b_256(lock_witness.raw_data().as_ref());
+                if actual_proof[..] == expected_proof[..] {
                     checked = true;
                     debug!(">>> >>> passed to check witness");
                 } else {
                     debug!(
-                        ">>> >>> failed to check witness: args: {:#x}, witness: {:#x}",
+                        ">>> >>> failed to check witness: args: {}, witness: {}",
                         args, lock_witness
                     );
                     return Err(Error::WitnessIsIncorrect);

contracts/can-update-without-ownership-lock/src/entry.rs

@@ -1,29 +1,41 @@
 use ckb_testtool::{
+    ckb_hash::blake2b_256,
     ckb_types::{bytes::Bytes, core::TransactionBuilder, packed::*, prelude::*},
     context::Context,
 };
 
 use crate::{prelude::*, utilities, Loader};
 
-fn run_test(inputs_capacity: &[u64], outputs_capacity: &[u64]) {
+struct Case {
+    inputs_capacity: Vec<u64>,
+    outputs_capacity: Vec<u64>,
+    unlocked: bool,
+    should_pass: bool,
+}
+
+fn run_test(case: &Case) {
     utilities::setup();
 
     let loader = Loader::default();
     let mut context = Context::default();
 
+    const PASSWORD: &[u8] = &[0x12, 0x34, 0x56, 0x78];
+
     // Deploy the lock script.
     let lock_script = {
         let lock_bin = loader.load_binary("can-update-without-ownership-lock");
         let lock_out_point = context.deploy_cell(lock_bin);
+        let args = blake2b_256(PASSWORD);
         context
             .build_script(&lock_out_point, Default::default())
             .expect("script")
             .as_builder()
-            .args([0u8, 1, 2, 3].pack())
+            .args((args[..]).pack())
             .build()
     };
 
-    let inputs = inputs_capacity
+    let inputs = case
+        .inputs_capacity
         .iter()
         .map(|cap| {
             let output = CellOutput::new_builder()
@@ -35,7 +47,8 @@ fn run_test(inputs_capacity: &[u64], outputs_capacity: &[u64]) {
         })
         .collect::<Vec<_>>();
 
-    let outputs = outputs_capacity
+    let outputs = case
+        .outputs_capacity
         .iter()
         .map(|cap| {
             CellOutput::new_builder()
@@ -46,67 +59,164 @@ fn run_test(inputs_capacity: &[u64], outputs_capacity: &[u64]) {
         .collect::<Vec<_>>();
     let outputs_data = vec![Bytes::new(); outputs.len()];
 
-    let tx = TransactionBuilder::default()
+    let tx_builder = TransactionBuilder::default()
         .inputs(inputs)
         .outputs(outputs)
-        .outputs_data(outputs_data.pack())
-        .build();
+        .outputs_data(outputs_data.pack());
+    let tx = if case.unlocked {
+        let witness = {
+            let type_args = BytesOpt::new_builder()
+                .set(Some(Pack::pack(PASSWORD)))
+                .build();
+            let witness_args = WitnessArgs::new_builder().lock(type_args).build();
+            witness_args.as_bytes()
+        };
+        tx_builder.witness(witness.pack())
+    } else {
+        tx_builder
+    }
+    .build();
     let tx = context.complete_tx(tx);
 
-    let inputs_total: u64 = inputs_capacity.iter().copied().sum();
-    let outputs_total: u64 = outputs_capacity.iter().copied().sum();
-    if inputs_total > outputs_total {
-        let _ = context.should_be_failed(&tx, MAX_CYCLES);
-    } else {
+    let inputs_total: u64 = case.inputs_capacity.iter().copied().sum();
+    let outputs_total: u64 = case.outputs_capacity.iter().copied().sum();
+    let expected_result = case.unlocked || inputs_total <= outputs_total;
+    assert_eq!(case.should_pass, expected_result);
+    if case.should_pass {
         let _ = context.should_be_passed(&tx, MAX_CYCLES);
+    } else {
+        let _ = context.should_be_failed(&tx, MAX_CYCLES);
     }
 }
 
 #[test]
-fn lost_capacity_case_1() {
-    let inputs_capacity = vec![1000];
-    let outputs_capacity = vec![1000];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn unchanged_case_1() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![1000],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_2() {
-    let inputs_capacity = vec![999];
-    let outputs_capacity = vec![1000];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn unchanged_case_2() {
+    let case = Case {
+        inputs_capacity: vec![499, 501],
+        outputs_capacity: vec![1000],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_3() {
-    let inputs_capacity = vec![1000];
-    let outputs_capacity = vec![999];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn unchanged_case_3() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![499, 501],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_4() {
-    let inputs_capacity = vec![500, 500];
-    let outputs_capacity = vec![999];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn increase_case_1() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![1001],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_5() {
-    let inputs_capacity = vec![500, 500];
-    let outputs_capacity = vec![1001];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn increase_case_2() {
+    let case = Case {
+        inputs_capacity: vec![499, 501],
+        outputs_capacity: vec![1001],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_6() {
-    let inputs_capacity = vec![250, 250, 250, 250];
-    let outputs_capacity = vec![500, 501];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn increase_case_3() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![500, 501],
+        unlocked: false,
+        should_pass: true,
+    };
+    run_test(&case);
 }
 
 #[test]
-fn lost_capacity_case_7() {
-    let inputs_capacity = vec![250, 250, 250, 250];
-    let outputs_capacity = vec![500, 499];
-    run_test(&inputs_capacity, &outputs_capacity);
+fn decrease_case_1a() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![999],
+        unlocked: false,
+        should_pass: false,
+    };
+    run_test(&case);
+}
+
+#[test]
+fn decrease_case_1b() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![999],
+        unlocked: true,
+        should_pass: true,
+    };
+    run_test(&case);
+}
+
+#[test]
+fn decrease_case_2a() {
+    let case = Case {
+        inputs_capacity: vec![499, 501],
+        outputs_capacity: vec![999],
+        unlocked: false,
+        should_pass: false,
+    };
+    run_test(&case);
+}
+
+#[test]
+fn decrease_case_2b() {
+    let case = Case {
+        inputs_capacity: vec![499, 501],
+        outputs_capacity: vec![999],
+        unlocked: true,
+        should_pass: true,
+    };
+    run_test(&case);
+}
+
+#[test]
+fn decrease_case_3a() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![499, 500],
+        unlocked: false,
+        should_pass: false,
+    };
+    run_test(&case);
+}
+
+#[test]
+fn decrease_case_3b() {
+    let case = Case {
+        inputs_capacity: vec![1000],
+        outputs_capacity: vec![499, 500],
+        unlocked: true,
+        should_pass: true,
+    };
+    run_test(&case);
 }