whiteflag v1

Cargo.toml

@@ -25,4 +25,5 @@ thiserror = "1.0.30"
 parking_lot = "0.12.0"
 x25519-dalek = "2.0.0-pre.1"
 rand_core = "0.6.3"
-sp-keyring = "5.0.0"
+sp-keyring = "5.0.0"
+regex = "1.5.5"

src/lib.rs

@@ -3,6 +3,7 @@ pub mod database;
 pub mod dh_tools;
 pub mod fennel;
 pub mod rsa_tools;
+pub mod whiteflag;
 
 use codec::{Decode, Encode};
 
@@ -11,6 +12,7 @@ pub use crate::database::*;
 pub use crate::dh_tools::*;
 pub use crate::fennel::*;
 pub use crate::rsa_tools::*;
+pub use crate::whiteflag::*;
 
 /// The FennelServerPacket struct is used for carrying formatted messages between the server and client.
 #[derive(Copy, Clone, Encode, Decode, Debug)]

src/whiteflag/mod.rs

@@ -0,0 +1,5 @@
+#[cfg(test)]
+mod tests;
+
+pub mod wf_codec;
+pub mod wf_core;

src/whiteflag/tests.rs

@@ -0,0 +1,69 @@
+use crate::whiteflag::wf_core::message::WhiteflagMessage;
+
+#[cfg(test)]
+#[test]
+fn test_create_new_message() {
+    let mut message = WhiteflagMessage::new("S".to_string());
+    assert_eq!(message.message_type, "S");
+    assert!(message.is_valid());
+
+    assert_eq!("WF", message.prefix);
+    assert_eq!("1", message.version);
+    assert_eq!("S", message.message_code);
+
+    assert!(message.set_encryption_indicator("1".to_string()));
+    assert!(!message.set_encryption_indicator("2".to_string()));
+
+    /* Verify body fields */
+    assert!(message.set_subject_code("10".to_string()));
+    assert!(!message.set_subject_code("20".to_string()));
+    assert!(message.set_object_type("21".to_string()));
+    assert!(!message.set_object_type("22".to_string()));
+
+    /* Verify metadata */
+    assert_eq!(None, message.set_transaction_hash("a1b2c3".to_string()));
+    assert_eq!(
+        "a1b2c3",
+        message.set_transaction_hash("d4e5f6".to_string()).unwrap()
+    );
+    assert_eq!(None, message.set_originator_address("abc123".to_string()));
+    assert_eq!("abc123", message.get_originator_address());
+}
+
+#[test]
+fn test_compile_auth_message() {
+    let field_values = vec![
+        "WF",
+        "1",
+        "0",
+        "0",
+        "A",
+        "0",
+        "0000000000000000000000000000000000000000000000000000000000000000",
+        "1",
+        "b01218a30dd3c23d050af254bfcce31a715fecdff6a23fd59609612e6e0ef263",
+    ];
+
+    let message = WhiteflagMessage::compile_auth_message(field_values.clone()).unwrap();
+
+    assert_eq!("A", message.message_type());
+    assert_eq!(field_values[0], message.prefix());
+    assert_eq!(field_values[1], message.version());
+    assert_eq!(field_values[2], message.get_encryption_indicator());
+    assert_eq!(field_values[3], message.duress_indictor());
+    assert_eq!(field_values[4], message.message_code());
+    assert_eq!(field_values[5], message.reference_indicator());
+    assert_eq!(field_values[6], message.referenced_message());
+    assert_eq!(field_values[7], message.verification_method());
+    assert_eq!(field_values[8], message.verification_data());
+    assert!(message.is_valid());
+}
+
+#[test]
+fn test_serialize_auth_message() {}
+
+#[test]
+fn test_deserialize_auth_message() {}
+
+#[test]
+fn test_decode_auth_message() {}

src/whiteflag/wf_codec/binary.rs

@@ -0,0 +1,44 @@
+use super::constants::BYTE;
+
+pub fn encode_binary<T: AsRef<str>>(binary_str: T) -> Vec<u8> {
+    let bit_length: usize = binary_str.as_ref().len();
+    let byte_length: usize = (bit_length / BYTE)
+        + (match bit_length % BYTE == 0 {
+            true => 0,
+            false => 1,
+        });
+    let mut buffer = vec![0; byte_length];
+
+    for bit_index in 0..bit_length {
+        if binary_str
+            .as_ref()
+            .chars()
+            .nth(bit_index)
+            .expect("something wrong")
+            == '1'
+        {
+            let byte_cursor: usize = bit_index / BYTE;
+            let bit_position: usize = bit_index % BYTE;
+            buffer[byte_cursor] |= 0x80 >> bit_position;
+        }
+    }
+
+    buffer
+}
+
+pub fn decode_binary(buffer: &[u8], bit_length: usize) -> String {
+    let mut data: Vec<char> = Vec::new();
+
+    for bit_index in 0..bit_length {
+        let byte_cursor: usize = bit_index / BYTE;
+        let bit_position: usize = bit_index % BYTE;
+
+        if (buffer[byte_cursor] >> (BYTE - bit_position - 1) & 1) == 1 {
+            data.push('1');
+        } else {
+            data.push('0');
+        }
+    }
+
+    data.into_iter().collect() //to lower?
+}