Share bill with external party logic (#564)

Author: zupzup

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 * Add `plaintext_hash` to Identity, Company and Bill Blocks, which is a hash over the plaintext data
     * (breaks all chains in the DB)
+* Add functionality for sharing a bill with an external party, encrypted, hashed, and signed, with the plaintext block data
+* Change visibility of `bill_service::error` and `bill_service::service` to private, moving the used types to `bill_service`
 
 # 0.3.17
 

crates/bcr-ebill-api/src/service/bill_service/mod.rs

@@ -20,14 +20,16 @@ use mockall::automock;
 
 /// Generic result type
 pub type Result<T> = std::result::Result<T, error::Error>;
+pub use service::BillService;
 
 mod blocks;
 mod data_fetching;
-pub mod error;
+mod error;
 mod issue;
 mod payment;
 mod propagation;
-pub mod service;
+mod service;
+mod sharing;
 #[cfg(test)]
 pub mod test_utils;
 

crates/bcr-ebill-api/src/service/bill_service/sharing.rs

@@ -0,0 +1,136 @@
+use bcr_ebill_core::{
+    bill::{BillId, BillToShareWithExternalParty},
+    util::BcrKeys,
+};
+use secp256k1::PublicKey;
+
+use crate::util;
+
+use super::{BillService, Result};
+
+impl BillService {
+    #[allow(dead_code)]
+    /// Creates a payload of a bill, including the encrypted and plaintext block data, encrypted
+    /// with the pub key of an external party, and signed by the sharer of the data, so the receiver
+    /// can fully validate the bill
+    pub(super) async fn share_bill_with_external_party(
+        &self,
+        bill_id: &BillId,
+        external_party_pub_key: &PublicKey,
+        sharer_keys: &BcrKeys,
+    ) -> Result<BillToShareWithExternalParty> {
+        let chain = self.blockchain_store.get_chain(bill_id).await?;
+        let bill_keys = self.store.get_keys(bill_id).await?;
+
+        let chain_with_plaintext = chain.get_chain_with_plaintext_block_data(&bill_keys)?;
+        let serialized = borsh::to_vec(&chain_with_plaintext)?;
+        let encrypted = util::crypto::encrypt_ecies(&serialized, external_party_pub_key)?;
+        let encoded = util::base58_encode(&encrypted);
+
+        let hash = util::sha256_hash(&serialized);
+        let signature = util::crypto::signature(&hash, &sharer_keys.get_private_key())?;
+
+        let result = BillToShareWithExternalParty {
+            bill_id: bill_id.to_owned(),
+            data: encoded,
+            hash,
+            signature,
+        };
+        Ok(result)
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use bcr_ebill_core::blockchain::{
+        Blockchain,
+        bill::{
+            BillBlock, BillBlockchain, BillOpCode,
+            block::{BillAcceptBlockData, BillIssueBlockData},
+            chain::BillBlockPlaintextWrapper,
+        },
+    };
+
+    use crate::{
+        service::bill_service::test_utils::{
+            accept_block, get_baseline_bill, get_baseline_identity, get_ctx, get_genesis_chain,
+            get_service,
+        },
+        tests::tests::{bill_id_test, bill_identified_participant_only_node_id, node_id_test},
+    };
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_share_bill_with_external_party() {
+        let external_party_keys = BcrKeys::new();
+        let external_party_pub_key = external_party_keys.pub_key();
+        let sharer_keys = BcrKeys::new();
+
+        let mut ctx = get_ctx();
+        let identity = get_baseline_identity();
+        let mut bill = get_baseline_bill(&bill_id_test());
+        let bill_id = bill.id.clone();
+        bill.drawee = bill_identified_participant_only_node_id(identity.identity.node_id.clone());
+        let drawee_node_id = bill.drawee.node_id.clone();
+
+        ctx.bill_blockchain_store
+            .expect_get_chain()
+            .returning(move |_| {
+                let mut chain = get_genesis_chain(Some(bill.clone()));
+                chain.try_add_block(accept_block(&bill.id, chain.get_latest_block()));
+                Ok(chain)
+            });
+
+        let service = get_service(ctx);
+
+        let result = service
+            .share_bill_with_external_party(&bill_id, &external_party_pub_key, &sharer_keys)
+            .await;
+        assert!(result.is_ok());
+
+        // Receiver side
+        let unwrapped = result.unwrap().clone();
+        assert_eq!(unwrapped.bill_id, bill_id);
+        let data = unwrapped.data;
+        let hash = unwrapped.hash;
+        let signature = unwrapped.signature;
+        // receiver can check that req was signed by the sharer
+        assert!(util::crypto::verify(&hash, &signature, &sharer_keys.pub_key()).unwrap());
+        let decoded = util::base58_decode(&data).unwrap();
+        // receiver can decrypt it
+        let decrypted =
+            util::crypto::decrypt_ecies(&decoded, &external_party_keys.get_private_key()).unwrap();
+        // receiver can check that hash matches the data
+        assert_eq!(hash, util::sha256_hash(&decrypted));
+        let deserialized: Vec<BillBlockPlaintextWrapper> = borsh::from_slice(&decrypted).unwrap();
+        // receiver can check that plaintext hashes match
+        for block_wrapper in deserialized.iter() {
+            assert_eq!(
+                block_wrapper.block.plaintext_hash,
+                util::sha256_hash(&block_wrapper.plaintext_data_bytes)
+            )
+        }
+        // receiver can check that chain is valid
+        BillBlockchain::new_from_blocks(
+            deserialized
+                .iter()
+                .map(|wrapper| wrapper.block.to_owned())
+                .collect::<Vec<BillBlock>>(),
+        )
+        .unwrap();
+        // receiver can access actual block data
+        let issue = deserialized[0].clone();
+        assert!(matches!(issue.block.op_code, BillOpCode::Issue));
+        let plaintext_issue: BillIssueBlockData =
+            borsh::from_slice(&issue.plaintext_data_bytes).unwrap();
+        assert_eq!(plaintext_issue.id, bill_id);
+        assert_eq!(plaintext_issue.drawee.node_id, drawee_node_id);
+
+        let accept = deserialized[1].clone();
+        assert!(matches!(accept.block.op_code, BillOpCode::Accept));
+        let plaintext_accept: BillAcceptBlockData =
+            borsh::from_slice(&accept.plaintext_data_bytes).unwrap();
+        assert_eq!(plaintext_accept.accepter.node_id, node_id_test());
+    }
+}

crates/bcr-ebill-api/src/service/mod.rs

@@ -31,7 +31,7 @@ pub enum Error {
 
     /// errors stemming from handling bills
     #[error("Bill service error: {0}")]
-    BillService(#[from] bill_service::error::Error),
+    BillService(#[from] bill_service::Error),
 
     /// errors stemming from crypto utils
     #[error("Crypto util error: {0}")]

crates/bcr-ebill-core/src/bill/mod.rs

@@ -610,3 +610,15 @@ pub struct PastPaymentDataRecourse {
     pub mempool_link_for_address_to_pay: String,
     pub status: PastPaymentStatus,
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct BillToShareWithExternalParty {
+    /// The bill id
+    pub bill_id: BillId,
+    /// The base58 encoded, encrypted BillBlockPlaintextWrapper of the bill
+    pub data: String,
+    /// The hash over the unencrypted data
+    pub hash: String,
+    /// The signature over the hash by the sharer of the bill
+    pub signature: String,
+}

crates/bcr-ebill-core/src/blockchain/bill/block.rs

@@ -28,7 +28,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::str::FromStr;
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct BillBlock {
     pub bill_id: BillId,
     pub id: u64,
@@ -37,6 +37,10 @@ pub struct BillBlock {
     pub previous_hash: String,
     pub timestamp: u64,
     pub data: String,
+    #[borsh(
+        serialize_with = "crate::util::borsh::serialize_pubkey",
+        deserialize_with = "crate::util::borsh::deserialize_pubkey"
+    )]
     pub public_key: PublicKey,
     pub signature: String,
     pub op_code: BillOpCode,

crates/bcr-ebill-core/src/blockchain/bill/chain.rs

@@ -1,9 +1,10 @@
 use super::super::Result;
 use super::PaymentInfo;
 use super::block::{
-    BillBlock, BillEndorseBlockData, BillIdentParticipantBlockData, BillIssueBlockData,
-    BillMintBlockData, BillOfferToSellBlockData, BillParticipantBlockData, BillRecourseBlockData,
-    BillRequestRecourseBlockData, BillSellBlockData,
+    BillAcceptBlockData, BillBlock, BillEndorseBlockData, BillIdentParticipantBlockData,
+    BillIssueBlockData, BillMintBlockData, BillOfferToSellBlockData, BillParticipantBlockData,
+    BillRecourseBlockData, BillRejectBlockData, BillRequestRecourseBlockData,
+    BillRequestToAcceptBlockData, BillRequestToPayBlockData, BillSellBlockData,
 };
 use super::{BillOpCode, RecourseWaitingForPayment};
 use super::{OfferToSellWaitingForPayment, RecoursePaymentInfo};
@@ -15,6 +16,7 @@ use crate::contact::{
     BillParticipant, ContactType, LightBillIdentParticipant, LightBillParticipant,
 };
 use crate::util::{self, BcrKeys};
+use borsh_derive::{BorshDeserialize, BorshSerialize};
 use log::error;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -27,7 +29,13 @@ pub struct BillParties {
     pub endorsee: Option<BillParticipantBlockData>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone)]
+pub struct BillBlockPlaintextWrapper {
+    pub block: BillBlock,
+    pub plaintext_data_bytes: Vec<u8>,
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone)]
 pub struct BillBlockchain {
     blocks: Vec<BillBlock>,
 }
@@ -701,6 +709,81 @@ impl BillBlockchain {
             endorsee: last_endorsee,
         })
     }
+
+    /// For each block, adds the decrypted and serialized plaintext data next to it
+    /// This is an expensive operation, since it deserialized, decrypts and reserializes the block data
+    /// validating the integrity of the data at the end
+    pub fn get_chain_with_plaintext_block_data(
+        &self,
+        bill_keys: &BillKeys,
+    ) -> Result<Vec<BillBlockPlaintextWrapper>> {
+        let mut result = Vec::with_capacity(self.blocks().len());
+        for block in self.blocks.iter() {
+            let plaintext_data_bytes = match block.op_code() {
+                BillOpCode::Issue => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillIssueBlockData>(bill_keys)?)?
+                }
+                BillOpCode::Accept => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillAcceptBlockData>(bill_keys)?)?
+                }
+                BillOpCode::Endorse => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillEndorseBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RequestToAccept => borsh::to_vec(
+                    &block.get_decrypted_block::<BillRequestToAcceptBlockData>(bill_keys)?,
+                )?,
+                BillOpCode::RequestToPay => borsh::to_vec(
+                    &block.get_decrypted_block::<BillRequestToPayBlockData>(bill_keys)?,
+                )?,
+                BillOpCode::OfferToSell => borsh::to_vec(
+                    &block.get_decrypted_block::<BillOfferToSellBlockData>(bill_keys)?,
+                )?,
+                BillOpCode::Sell => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillSellBlockData>(bill_keys)?)?
+                }
+                BillOpCode::Mint => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillMintBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RejectToAccept => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillRejectBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RejectToPay => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillRejectBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RejectToBuy => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillRejectBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RejectToPayRecourse => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillRejectBlockData>(bill_keys)?)?
+                }
+                BillOpCode::RequestRecourse => borsh::to_vec(
+                    &block.get_decrypted_block::<BillRequestRecourseBlockData>(bill_keys)?,
+                )?,
+                BillOpCode::Recourse => {
+                    borsh::to_vec(&block.get_decrypted_block::<BillRecourseBlockData>(bill_keys)?)?
+                }
+            };
+
+            if block.plaintext_hash != util::sha256_hash(&plaintext_data_bytes) {
+                return Err(Error::BlockInvalid);
+            }
+
+            result.push(BillBlockPlaintextWrapper {
+                block: block.clone(),
+                plaintext_data_bytes,
+            });
+        }
+
+        // Validate the chain from the wrapper
+        BillBlockchain::new_from_blocks(
+            result
+                .iter()
+                .map(|wrapper| wrapper.block.to_owned())
+                .collect::<Vec<BillBlock>>(),
+        )?;
+
+        Ok(result)
+    }
 }
 
 #[cfg(test)]
@@ -868,7 +951,7 @@ mod tests {
             node_id_last_endorsee.clone(),
             identity.identity.node_id.to_owned(),
             chain.get_first_block()
-        ),));
+        )));
 
         let keys = get_bill_keys();
         let result = chain.get_all_nodes_from_bill(&keys);
@@ -942,4 +1025,41 @@ mod tests {
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].id, 2);
     }
+
+    #[test]
+    fn test_get_serialized_chain_with_plaintext() {
+        let bill = empty_bitcredit_bill();
+        let bill_id = bill.id.clone();
+        let bill_keys = get_bill_keys();
+        let identity = get_baseline_identity();
+        let mut chain = BillBlockchain::new(
+            &BillIssueBlockData::from(bill, None, 1731593928),
+            identity.key_pair,
+            None,
+            BcrKeys::from_private_key(&bill_keys.private_key).unwrap(),
+            1731593928,
+        )
+        .unwrap();
+        let node_id_last_endorsee =
+            NodeId::new(BcrKeys::new().pub_key(), bitcoin::Network::Testnet);
+        assert!(chain.try_add_block(get_offer_to_sell_block(
+            node_id_last_endorsee.clone(),
+            identity.identity.node_id.to_owned(),
+            chain.get_first_block()
+        )));
+
+        let chain_with_plaintext = chain.get_chain_with_plaintext_block_data(&bill_keys);
+        assert!(chain_with_plaintext.is_ok());
+        assert_eq!(chain_with_plaintext.as_ref().unwrap().len(), 2);
+
+        let first = chain_with_plaintext.as_ref().unwrap()[0].clone();
+        let decrypted_block_data: BillIssueBlockData =
+            borsh::from_slice(&first.plaintext_data_bytes).unwrap();
+        assert_eq!(decrypted_block_data.id, bill_id);
+
+        let second = chain_with_plaintext.as_ref().unwrap()[1].clone();
+        let decrypted_block_data: BillOfferToSellBlockData =
+            borsh::from_slice(&second.plaintext_data_bytes).unwrap();
+        assert_eq!(decrypted_block_data.buyer.node_id(), node_id_last_endorsee);
+    }
 }