fix(dst-accumulation): verify aggregated signature with proof chain

maidsafe · Feb 25, 2021 · bd99595 · bd99595
1 parent f892838
commit bd99595
Show file tree

Hide file tree

Showing 3 changed files with 39 additions and 17 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -25,7 +25,7 @@ rand_chacha = "~0.2.2"
 thiserror = "1.0.23"
 xor_name = "1.1.0"
 resource_proof = "0.8.0"
-sn_messaging = { git = "https://github.com/lionel1704/sn_messaging", branch = "acc-at-dest" }
+sn_messaging = "~6.0.0"
 sn_data_types = "~0.15.0"
 
   [dependencies.bls]

diff --git a/src/messages/mod.rs b/src/messages/mod.rs
@@ -241,16 +241,31 @@ impl Message {
                     .map(|(_, key)| key);
                 self.variant.verify(self.proof_chain.as_ref(), trusted_keys)
             }
-            SrcAuthority::BlsShare { proof_share, .. } => {
-                if proof_share
+            SrcAuthority::BlsShare {
+                proof_share,
+                public_key,
+                ..
+            } => {
+                // Proof chain is required for accumulation at destination.
+                let proof_chain = if let Some(proof_chain) = self.proof_chain.as_ref() {
+                    proof_chain
+                } else {
+                    return Err(Error::InvalidMessage);
+                };
+
+                if !proof_share
                     .public_key_set
                     .public_key_share(proof_share.index)
                     .verify(&proof_share.signature_share, &bytes)
                 {
-                    Ok(VerifyStatus::Full)
-                } else {
-                    Err(Error::FailedSignature)
+                    return Err(Error::FailedSignature);
                 }
+                let trusted_keys = trusted_keys
+                    .into_iter()
+                    .filter(|(known_prefix, _)| known_prefix.matches(&name(public_key)))
+                    .map(|(_, key)| key);
+
+                proof_chain.check_trust(trusted_keys).into()
             }
             SrcAuthority::Section { prefix, signature } => {
                 // Proof chain is required for section-src messages.

diff --git a/src/routing/approved.rs b/src/routing/approved.rs
@@ -670,17 +670,24 @@ impl Approved {
             Variant::UserMessage(content) => {
                 if msg.dst() == &DstLocation::AccumulatingNode(self.node().name()) {
                     if let SrcAuthority::BlsShare { proof_share, .. } = msg.src() {
-                        match self.message_accumulator.add(
-                            &bincode::serialize(&msg.signable_view())?,
-                            proof_share.clone(),
-                        ) {
-                            Ok(_) => {
+                        let signed_bytes = bincode::serialize(&msg.signable_view())?;
+                        match self
+                            .message_accumulator
+                            .add(&signed_bytes, proof_share.clone())
+                        {
+                            Ok(proof) => {
                                 trace!("Successfully accumulated message: {:?}", msg);
-                                self.handle_user_message(
-                                    msg.src().src_location(),
-                                    *msg.dst(),
-                                    content.clone(),
-                                )
+                                let key = msg.proof_chain_last_key()?;
+                                if key.verify(&proof.signature, signed_bytes) {
+                                    self.handle_user_message(
+                                        msg.src().src_location(),
+                                        *msg.dst(),
+                                        content.clone(),
+                                    )
+                                } else {
+                                    trace!("Aggregated signature is invalid. Handling message {:?} skipped", msg);
+                                    Ok(vec![])
+                                }
                             }
                             Err(err) => {
                                 trace!("Error accumulating message at destination: {:?}", err);
@@ -2061,7 +2068,7 @@ impl Approved {
                         self.section_keys_provider.key_share()?,
                         dst,
                         variant,
-                        None,
+                        Some(self.section().create_proof_chain_for_our_info(None)),
                         None,
                     )?
                 } else {