MessageBuilder

Cargo.lock

@@ -210,6 +210,12 @@ dependencies = [
  "wasi 0.10.2+wasi-snapshot-preview1",
 ]
 
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -229,6 +235,7 @@ dependencies = [
  "rayon",
  "rsa",
  "serde",
+ "serde_cbor",
  "sha2",
 ]
 
@@ -505,6 +512,16 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.130"

Cargo.toml

@@ -19,6 +19,7 @@ rsa = { version = "0.5", features = ["serde"] }
 serde = { version = "1.0", features = ["derive", "alloc"], default-features = false }
 rayon = { version = "1.5.1", optional = true }
 core-error = "0.0.1-rc4"
+serde_cbor = "0.11.2"
 
 [profile.dev.package.num-bigint-dig]
 opt-level = 3

src/crypto.rs

@@ -25,6 +25,10 @@ impl PublicKey {
     pub fn encrypt_data(&self, data: &[u8]) -> RsaRes<Vec<u8>> {
         self.key.encrypt(&mut OsRng {}, PaddingScheme::PKCS1v15Encrypt, data)
     }
+
+    pub fn to_vec(&self) -> serde_cbor::Result<Vec<u8>> {
+        serde_cbor::to_vec(&self)
+    }
 }
 
 /// Key pair (public and secret) for a node, should be stored locally

src/ironforce.rs

@@ -37,6 +37,11 @@ impl IronForce {
         todo!()
     }
 
+    /// Send a multicast or broadcast message
+    fn send_to_all(&mut self, _message: Message) -> IFResult<()> {
+        todo!()
+    }
+
     /// Send a message through tunnel
     fn send_through_tunnel(&mut self, _tunnel_id: u64, _message: Message, _direction: Option<bool>) -> IFResult<()> {
         todo!()

src/message.rs

@@ -57,11 +57,16 @@ pub enum MessageContent {
     Plain(Vec<u8>),
     /// Message content bytes encrypted for the recipient
     Encrypted(Vec<u8>),
+    /// There is no content
+    None,
 }
 
+/// The struct for messages that are sent in the network
 #[derive(Serialize, Deserialize, Clone)]
 pub struct Message {
     /// Content of the message (not to be confused with the bytes that we are sending through interfaces)
+    ///
+    /// AKA useful payload
     pub content: MessageContent,
     /// The type of this message
     pub message_type: MessageType,
@@ -95,7 +100,104 @@ impl Message {
         todo!()
     }
 
-    pub fn calculate_hash(_content: MessageContent, _message_type: MessageType, _sender: Option<PublicKey>) -> Vec<u8> {
+    pub fn calculate_hash(_content: &MessageContent, _message_type: MessageType, _sender_or_encrypted_sender: Option<Vec<u8>>) -> Vec<u8> {
         todo!()
     }
+
+    /// Encrypt hash of the message for the recipient
+    pub fn generate_recipient_verification(hash: Vec<u8>, recipient: PublicKey) -> rsa::errors::Result<Vec<u8>> {
+        recipient.encrypt_data(&hash)
+    }
+}
+
+
+/// Message builder to create a new message step-by-step, like `Message::build().message_type(...).sign(...)`
+pub struct MessageBuilder {
+    content: MessageContent,
+    /// The type of the message to be built
+    message_type: Option<MessageType>,
+    /// Sender's keys
+    sender: Option<Keys>,
+    /// Recipient's public key (if present, the content will be encrypted and recipient verification field will be set)
+    recipient: Option<PublicKey>,
+    /// ID of the tunnel that is used
+    tunnel_id: u64,
+}
+
+impl MessageBuilder {
+    /// Create a new `MessageBuilder` with default parameters
+    pub fn new() -> Self {
+        Self {
+            content: MessageContent::None,
+            message_type: None,
+            sender: None,
+            recipient: None,
+            tunnel_id: 0,
+        }
+    }
+
+    pub fn content(mut self, cont: Vec<u8>) -> Self {
+        self.content = MessageContent::Plain(cont);
+        self
+    }
+
+    /// Sign the message
+    pub fn sign(mut self, keys: &Keys) -> Self {
+        self.sender = Some(keys.clone());
+        self
+    }
+
+    /// Set message's recipient (and therefore set recipient verification and encrypt the content)
+    pub fn recipient(mut self, recipient: PublicKey) -> Self {
+        self.recipient = Some(recipient);
+        self
+    }
+
+    /// Set tunnel id
+    pub fn tunnel(mut self, tunnel_id: u64) -> Self {
+        self.tunnel_id = tunnel_id;
+        self
+    }
+
+    /// Set message's type
+    pub fn message_type(mut self, message_type: MessageType) -> Self {
+        self.message_type = Some(message_type);
+        self
+    }
+
+    /// Get the resulting message
+    pub fn build(self) -> IFResult<Message> {
+        let salt = rand::random();
+        let sender_encrypted = if let (Some(sender_keys), Some(recipient)) = (self.sender.as_ref(), self.recipient.as_ref()) {
+            Some(recipient.encrypt_data(&sender_keys.get_public().to_vec()?)?)
+        } else { None };
+        let hash = Message::calculate_hash(
+            &self.content,
+            self.message_type.clone().unwrap(),
+            sender_encrypted.clone()
+                .or_else(
+                    || self.sender.as_ref()
+                        .map(|sender_keys| sender_keys.get_public().to_vec().unwrap())
+                ),
+        );
+        let recipient_verification = self.recipient.as_ref().map(|rec| rec.encrypt_data(&hash).unwrap());
+        let signature = match (self.sender, self.recipient) {
+            (Some(sender_keys), Some(recipient_key)) => Signature::SignedPrivately {
+                sender_encrypted: sender_encrypted.unwrap(),
+                signature: recipient_key.encrypt_data(&sender_keys.sign(&hash)?)?,
+            },
+            (Some(sender_keys), None) => Signature::Signed { sender: sender_keys.get_public(), signature: sender_keys.sign(&hash)? },
+            (None, _) => Signature::NotSigned,
+        };
+        Ok(Message {
+            content: self.content,
+            message_type: self.message_type.unwrap(),
+            signature,
+            salt,
+            hash,
+            recipient_verification,
+            tunnel_id: self.tunnel_id,
+            network_info: Default::default(),
+        })
+    }
 }

src/res.rs

@@ -9,13 +9,29 @@ pub enum IFError {
     General(String),
     /// A tunnel satisfying some conditions has not been found
     TunnelNotFound,
+    /// Error during serialization
+    SerializationError(String),
+    /// Error in rsa
+    CryptoError(String),
 }
 
 
-impl<T: Debug + core_error::Error> From<T> for IFError {
+// impl<T: Debug + core_error::Error> From<T> for IFError {
-    /// Convert from other error
+//     /// Convert from other error
-    fn from(e: T) -> Self {
+//     fn from(e: T) -> Self {
-        Self::General(format!("{:?}", e))
+//         Self::General(format!("{:?}", e))
+//     }
+// }
+
+impl From<serde_cbor::Error> for IFError {
+    fn from(e: serde_cbor::Error) -> Self {
+        Self::SerializationError(format!("{:?}", e))
+    }
+}
+
+impl From<rsa::errors::Error> for IFError {
+    fn from(e: rsa::errors::Error) -> Self {
+        Self::CryptoError(format!("{:?}", e))
     }
 }