update (encrytion): creating df1t-encrytion

src/encpt/encrypt.rs

@@ -5,7 +5,8 @@ use crate::encpt::mapping::switcher::switch_chars;
 use crate::encpt::math::matrix::{calc_n, char_to_mtrx, fill_mtrx_gaps, mtrx_to_vecs};
 use crate::encpt::math::process::add_to_vec;
 use crate::shared::parse::{
-    flatten_vec, split_by_n, split_string, str2_string_vec, string_vec2_str,
+    flatten_vec, get_elements_by_indexes, join_string, move_elements_right, split_by_n,
+    split_string, str2_string_vec, string_vec2_str,
 };
 use crate::{chr_to_mp, chr_to_mxas, salt_extender, MpType};
 
@@ -20,10 +21,10 @@ impl fmt::Display for ValueError {
 }
 
 impl Error for ValueError {}
-
+#[derive(Debug)]
 struct EncptInfo {
     original_length: usize,
-    salt_short: i8, // 0 : buffer, 1 : salt
+    salt_short: usize, // 0 : buffer, 1 : salt
     mtrx_n: usize,
     rd_len: usize,
 }
@@ -34,47 +35,76 @@ pub fn is_salt_short<'a>(buffer: &'a str, salt: &'a str) -> bool {
     return false;
 }
 
+pub fn flt_subvecs(n: usize, vc: Vec<i32>) -> Vec<String> {
+    let flt = flatten_vec(
+        add_to_vec(n as i32, vc)
+            .iter()
+            .map(|&c| c.to_string())
+            .collect(),
+    );
+    flt
+}
+pub fn ceaser_swap(indxs: Vec<String>, n: usize) -> Vec<&'static str> {
+    let swp = get_elements_by_indexes(
+        move_elements_right(n),
+        indxs.iter().map(|c| c.parse::<i32>().unwrap()).collect(),
+    );
+    swp
+}
+
+pub fn cyph_info(strct_element: usize) -> Vec<&'static str> {
+    let cph = get_elements_by_indexes(
+        move_elements_right(0),
+        flatten_vec(split_string(strct_element.to_string().as_str()))
+            .iter()
+            .map(|c| c.parse::<i32>().unwrap())
+            .collect(),
+    );
+    cph
+}
 pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Error>> {
     if salt.len() > 16 {
         return Err(Box::new(ValueError {
             message: "Salt can't be more than 16 char".to_string(),
         }));
     };
 
-    // add original length
-    //
-    // .....
-    //
-
     // Extend the shotest string
     let extended: String;
     match salt_extender(&salt, &buffer) {
         Ok(res) => extended = res,
         Err(err) => panic!("{}", err),
     }
-    println!("im extended {}", extended);
 
     // split the buffer and salt into vectors and parse them to mapped version
     let mut binding1: Vec<String> = split_string(&buffer);
     let mut binding2: Vec<String> = split_string(&salt);
-
+    let mut shrt = 0;
     match is_salt_short(&buffer, &salt) {
-        true => binding2 = split_string(&extended), // + add the shortest in struct
+        true => {
+            binding2 = split_string(&extended);
+            shrt = 1
+        } // + add the shortest in struct
         false => binding1 = split_string(&extended),
     }
 
-    let buffer_vec = chr_to_mp(string_vec2_str(&binding1), MpType::CharMap);
-    let salt_vec = chr_to_mp(string_vec2_str(&binding2), MpType::SaltMap);
-    println!("im buffer {:?}", &buffer_vec);
-    println!("im salt {:?}", &salt_vec);
+    let buffer_vec: Vec<&str>;
+    match chr_to_mp(string_vec2_str(&binding1), MpType::CharMap) {
+        Ok(t) => buffer_vec = t,
+        Err(e) => panic!("{}", e),
+    };
+    let salt_vec: Vec<&str>;
+    match chr_to_mp(string_vec2_str(&binding2), MpType::SaltMap) {
+        Ok(t) => salt_vec = t,
+        Err(e) => panic!("{}", e),
+    };
 
     // Salt and buffer mixing
     let mixed: Vec<String>;
     match switch_chars(salt_vec, buffer_vec) {
         Ok(t) => mixed = t,
         Err(e) => panic!("{}", e),
     }
-    println!("im mixed {:?}", &mixed);
 
     // map the mixed vec into mx_as vec version
     let binding3 = flatten_vec(mixed);
@@ -84,29 +114,57 @@ pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
         Err(e) => panic!("{}", e),
     }
     let mtrx_n = calc_n(mx_version.len());
-    // add mtrx_n to struct
 
     // split the chunk into unstructered matrix
     let splitted_empty = split_by_n(mtrx_n, str2_string_vec(mx_version));
     // structure the matrix by filling the gaps with 0's
     let splitted_filled = fill_mtrx_gaps(mtrx_n, char_to_mtrx(splitted_empty));
     // get the green, red, blue vecs from the matrix
     let vecs_from_mtrx = mtrx_to_vecs(splitted_filled);
+
     let grn = &vecs_from_mtrx[0];
     let rd = &vecs_from_mtrx[1];
     let ble = &vecs_from_mtrx[2];
     // add mtrx_n to green and blue and the red length to red
-    let grn_a = add_to_vec(mtrx_n as i32, grn.to_vec());
-    let rd_a = add_to_vec(rd.len() as i32, rd.to_vec());
-    let ble_a = add_to_vec(mtrx_n as i32, ble.to_vec());
+    let grn_a: Vec<String> = flt_subvecs(mtrx_n, grn.to_vec());
+    let rd_a: Vec<String> = flt_subvecs(rd.len(), rd.to_vec());
+    let ble_a: Vec<String> = flt_subvecs(mtrx_n, ble.to_vec());
+    // ceaser
+    let grn_swapped = ceaser_swap(grn_a.clone(), grn_a.len() + 2);
+    let rd_swapped = ceaser_swap(rd_a.clone(), rd_a.len());
+    let ble_swapped = ceaser_swap(ble_a.clone(), ble_a.len() + rd_a.len() + 1);
+
     // create a new matrix of the new values
-    let parsed_mtrx: Vec<Vec<String>> = vec![grn_a, rd_a, ble_a]
-        .iter()
-        .map(|c| flatten_vec(c.iter().map(|&c| c.to_string()).collect()))
-        .collect();
+    let parsed_mtrx: Vec<Vec<String>> =
+        vec![grn_swapped, vec!["$"], rd_swapped, vec!["$"], ble_swapped]
+            .iter()
+            .map(|c| flatten_vec(c.iter().map(|&c| c.to_string()).collect()))
+            .collect();
+
     // faltten the matrix
     let flat_mtrx: Vec<String> = parsed_mtrx.into_iter().flatten().collect();
-    println!("to string {:?}", flat_mtrx);
-    // println!("blue {:?}", ble_a);
-    Ok("done".to_string())
+
+    // fulfill info and encrypt it
+    let info = EncptInfo {
+        original_length: buffer.len(),
+        salt_short: shrt,
+        mtrx_n: mtrx_n,
+        rd_len: rd.len(),
+    };
+    let orgnl = cyph_info(info.original_length);
+    let slt_shrt = cyph_info(info.salt_short);
+    let mtrn = cyph_info(info.mtrx_n);
+    let rdln = cyph_info(info.rd_len);
+    let info_vec = vec![
+        join_string(str2_string_vec(orgnl)),
+        ";".to_string(),
+        join_string(str2_string_vec(slt_shrt)),
+        ";".to_string(),
+        join_string(str2_string_vec(mtrn)),
+        ";".to_string(),
+        join_string(str2_string_vec(rdln)),
+        "$".to_string(),
+    ];
+    // join info + encrypted
+    Ok(join_string(info_vec) + &join_string(flat_mtrx))
 }

src/encpt/mapping/mapper.rs

@@ -11,7 +11,7 @@ pub enum MpType {
 }
 
 // map strings to vectors
-pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType) -> Vec<&str> {
+pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType) -> Result<Vec<&str>, &str> {
     let mut result: Vec<&str> = vec![];
     let mpp: [[&str; 3]; 85];
     match mpt {
@@ -25,8 +25,11 @@ pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType) -> Vec<&str> {
             }
         }
     }
-
-    result
+    if result.len() != vc.len() {
+        Err("CharError: unrecognized char")
+    } else {
+        Ok(result)
+    }
 }
 
 pub fn chr_to_mxas(vc: Vec<&str>) -> Result<Vec<&str>, &str> {
@@ -40,7 +43,7 @@ pub fn chr_to_mxas(vc: Vec<&str>) -> Result<Vec<&str>, &str> {
         }
     }
     if result.len() != vc.len() {
-        Err("No matching characters found")
+        Err("CharError: unrecognized char")
     } else {
         Ok(result)
     }
@@ -105,7 +108,7 @@ mod tests {
     #[test]
     fn try_char() {
         let res = chr_to_mp(vec!["A", "B", "C"], MpType::CharMap);
-        assert_eq!(res, vec!["Av", "bQ", "TG"])
+        assert_eq!(res, Ok(vec!["Av", "bQ", "TG"]))
     }
     #[test]
     fn salt_extender_longer() {

src/main.rs

@@ -1,21 +1,6 @@
-use crate::{
-    encpt::{
-        encrypt::df1t_encrypt,
-        mapping::{
-            construct::{self, construct_str},
-            mapper::*,
-        },
-        math::matrix::fill_mtrx_gaps,
-    },
-    shared::parse::str2_string_vec,
-};
-use encpt::{
-    mapping::switcher::switch_chars,
-    math::matrix::{char_to_mtrx, mtrx_to_vecs},
-};
+use crate::encpt::{encrypt::df1t_encrypt, mapping::mapper::*};
 pub mod maps {
     pub mod chars;
-    pub mod nums;
     pub mod salt;
 }
 mod shared {
@@ -28,7 +13,6 @@ mod encpt {
         pub mod process;
     }
     pub mod mapping {
-        pub mod construct;
         pub mod mapper;
         pub mod switcher;
     }
@@ -75,8 +59,8 @@ fn main() {
     //     println!("{:?}", d);
     // }
     // Example usage
-    let salt = "ABCDER";
-    let password = "SUPER";
+    let salt = "sqdfqfgsffdqsdf";
+    let password = "radqsfdfdfdqsdf";
     let res = df1t_encrypt(password.to_owned(), salt.to_owned());
     println!("{}", res.unwrap())
 }

src/shared/parse.rs

@@ -38,6 +38,41 @@ pub fn rem_zeros(chunk: Vec<i32>) -> (Vec<i32>, usize) {
     let filtered_chunk: Vec<i32> = chunk.into_iter().filter(|&c| c != 0).collect();
     (filtered_chunk, count_zeros)
 }
+
+pub fn move_elements_right(n: usize) -> Vec<&'static str> {
+    let vec = vec![
+        "e", "M", "y", "P", "c", "6", "I", "-", "8", "u", "F", "@", "b", "T", "w", ".", "J", "O",
+        "z", "p", ":", "W", "7", "v", "V", "K", "5", "H", "q", "f", "&", "/", "A", "{", "Z", "d",
+        "L", "9", "N", "R", "*", "h", "0", "D", "G", "]", "s", "3", "S", "r", "2", "Q", "}", "g",
+        "X", "x", "k", "<", "B", "(", "C", "j", "!", "U", "m", "a", "i", "o", "4", "l", "1", "E",
+        "t", "n",
+    ];
+    let len = vec.len();
+    if len == 0 {
+        return vec;
+    }
+    if n == 0 {
+        return vec;
+    }
+
+    let n = n % len; // Ensure n is within the range of vector length
+
+    // Create a new vector with the elements moved to the right
+    let mut new_vec = vec![Default::default(); len];
+    for i in 0..len {
+        new_vec[(i + n) % len] = vec[i].clone();
+    }
+
+    new_vec
+}
+
+pub fn get_elements_by_indexes(original: Vec<&str>, indexes: Vec<i32>) -> Vec<&str> {
+    indexes
+        .iter()
+        .filter_map(|&i| original.get(i as usize).cloned())
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;