update (decrytion): creating the decpt - still not fully tested, lib …

…translated

src/encpt/decrypt.rs

@@ -1,23 +1,22 @@
 use std::{error::Error, i32};
 
 use crate::{
-    encpt::math::{matrix::vecs_to_mtrx, process::rem_from_vec},
-    mxas_to_chars,
+    chr_to_mp, chr_to_mxas,
+    encpt::{
+        mapping::switcher::reference_to_origin,
+        math::{matrix::vecs_to_mtrx, process::rem_from_vec},
+    },
+    salt_extender,
     shared::parse::{
-        concat_every_n_elements, get_indexes, move_elements, rem_zeros, split_string,
-        string_vec2_str, Mv_Direction,
+        concat_every_n_elements, generate_a_string, get_indexes, join_string, move_elements,
+        pop_elements_from_vector, rem_zeros, split_string, str2_string_vec, string_vec2_str,
+        Mv_Direction,
     },
+    DirecType, MpType,
 };
 
 use super::analyse::read::reader;
 
-#[derive(Debug)]
-struct EncptInfo {
-    original_length: usize,
-    salt_short: usize, // 0 : buffer, 1 : salt
-    mtrx_n: usize,
-}
-
 pub fn ceaser_unswap(indxs: Vec<String>, n: usize) -> Vec<i32> {
     let swp = get_indexes(
         move_elements(n, Mv_Direction::RIGHT),
@@ -29,10 +28,28 @@ pub fn ceaser_unswap(indxs: Vec<String>, n: usize) -> Vec<i32> {
         .map(|c| c.parse::<i32>().unwrap())
         .collect()
 }
+pub fn ref_to_bfr_vec(salt: String, mx_as_to_char: Vec<String>) -> Vec<String> {
+    let salt_vec: Vec<&str>;
+
+    let binding = split_string(&salt);
+    match chr_to_mp(
+        string_vec2_str(&binding),
+        MpType::SaltMap,
+        DirecType::FORWARD,
+    ) {
+        Ok(t) => salt_vec = t,
+        Err(e) => panic!("{}", e),
+    };
+    let bfr_vec: Vec<String>;
+    match reference_to_origin(salt_vec, string_vec2_str(&mx_as_to_char)) {
+        Ok(t) => bfr_vec = t,
+        Err(e) => panic!("{}", e),
+    };
+    bfr_vec
+}
 pub fn df1t_decrypt(buffer: String, salt: String) -> Result<String, Box<dyn Error>> {
     let parsed_buffer = reader(buffer, "$");
-    let info = &parsed_buffer[0];
-    let parsed_info = reader(info.to_string(), ";");
+
     // split each vector
     let grn = split_string(&parsed_buffer[1]);
     let rd = split_string(&parsed_buffer[2]);
@@ -53,13 +70,64 @@ pub fn df1t_decrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
         .map(|c| c.to_string())
         .collect();
 
+    // extended version of buffer
     let mx_as_to_char: Vec<String>;
-    match mxas_to_chars(string_vec2_str(&restored_mtrx)) {
+    match chr_to_mxas(string_vec2_str(&restored_mtrx), DirecType::BACKWARD) {
         Ok(t) => mx_as_to_char = concat_every_n_elements(t, 2),
         Err(e) => panic!("{}", e),
     };
-    println!("{:?}", mx_as_to_char);
-    Ok(salt)
+
+    // original length of the buffer before cyph
+    let orgnl = ceaser_unswap(split_string(&parsed_buffer[0].clone()), 142);
+
+    if orgnl[0] > salt.len() as i32 {
+        // extending the salt
+        let virt_str = generate_a_string(orgnl[0] as usize);
+        let slt_extd: String;
+        match salt_extender(&salt, &virt_str) {
+            Ok(t) => slt_extd = t,
+            Err(e) => panic!("{}", e),
+        };
+        // translating the salt to first level map
+        let bfr_vec = ref_to_bfr_vec(slt_extd, mx_as_to_char);
+        println!("{:?}", bfr_vec);
+        match chr_to_mp(
+            string_vec2_str(&bfr_vec),
+            MpType::CharMap,
+            DirecType::BACKWARD,
+        ) {
+            Ok(t) => return Ok(join_string(str2_string_vec(t))),
+            Err(e) => panic!("{}", e),
+        };
+        // last parse
+    } else if orgnl[0] < salt.len() as i32 {
+        // translating the salt to first level map
+        let mut bfr_vec = ref_to_bfr_vec(salt.clone(), mx_as_to_char);
+        // pop the extended elements
+        pop_elements_from_vector(&mut bfr_vec, salt.len() - orgnl[0] as usize);
+        println!("{:?}", bfr_vec);
+
+        match chr_to_mp(
+            string_vec2_str(&bfr_vec),
+            MpType::CharMap,
+            DirecType::BACKWARD,
+        ) {
+            Ok(t) => return Ok(join_string(str2_string_vec(t))),
+            Err(e) => panic!("{}", e),
+        };
+    } else {
+        // translating the salt to first level map
+        let bfr_vec = ref_to_bfr_vec(salt.clone(), mx_as_to_char);
+        println!("{:?}", bfr_vec);
+        match chr_to_mp(
+            string_vec2_str(&bfr_vec),
+            MpType::CharMap,
+            DirecType::BACKWARD,
+        ) {
+            Ok(t) => return Ok(join_string(str2_string_vec(t))),
+            Err(e) => panic!("{}", e),
+        };
+    }
 }
 
 // mx version ["652", "165", "314", "671", "113", "422", "103", "923", "314", "194", "113", "389", "314", "422", "652", "923", "113", "194", "103", "422", "652", "389"]

src/encpt/encrypt.rs

@@ -8,7 +8,7 @@ use crate::shared::parse::{
     flatten_vec, get_elements_by_indexes, join_string, move_elements, split_by_n, split_string,
     str2_string_vec, string_vec2_str, Mv_Direction,
 };
-use crate::{chr_to_mp, chr_to_mxas, salt_extender, MpType};
+use crate::{chr_to_mp, chr_to_mxas, salt_extender, DirecType, MpType};
 
 #[derive(Debug)]
 struct ValueError {
@@ -21,11 +21,7 @@ impl fmt::Display for ValueError {
 }
 
 impl Error for ValueError {}
-#[derive(Debug)]
-struct EncptInfo {
-    original_length: usize,
-    salt_short: usize, // 0 : buffer, 1 : salt
-}
+
 pub fn is_salt_short<'a>(buffer: &'a str, salt: &'a str) -> bool {
     if buffer.len() > salt.len() {
         return true;
@@ -77,26 +73,41 @@ pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
     // 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);
-            shrt = 1
         } // + add the shortest in struct
         false => binding1 = split_string(&extended),
     }
+    match is_salt_short(&buffer, &salt) {
+        true => {
+            println!("true")
+        } // + add the shortest in struct
+        false => println!("false"),
+    }
 
     let buffer_vec: Vec<&str>;
-    match chr_to_mp(string_vec2_str(&binding1), MpType::CharMap) {
+    match chr_to_mp(
+        string_vec2_str(&binding1),
+        MpType::CharMap,
+        DirecType::FORWARD,
+    ) {
         Ok(t) => buffer_vec = t,
         Err(e) => panic!("{}", e),
     };
     let salt_vec: Vec<&str>;
-    match chr_to_mp(string_vec2_str(&binding2), MpType::SaltMap) {
+    match chr_to_mp(
+        string_vec2_str(&binding2),
+        MpType::SaltMap,
+        DirecType::FORWARD,
+    ) {
         Ok(t) => salt_vec = t,
         Err(e) => panic!("{}", e),
     };
+    println!("im buffer vec : {:?}", &buffer_vec);
 
+    println!("salt vec encpt {:?}", &salt_vec);
     // Salt and buffer mixing
     let mixed: Vec<String>;
     match switch_chars(salt_vec, buffer_vec) {
@@ -109,7 +120,7 @@ pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
     let binding3 = flatten_vec(mixed);
     println!("bin3 {:?}", binding3);
     let mx_version: Vec<&str>;
-    match chr_to_mxas(string_vec2_str(&binding3)) {
+    match chr_to_mxas(string_vec2_str(&binding3), DirecType::FORWARD) {
         Ok(t) => mx_version = t,
         Err(e) => panic!("{}", e),
     }
@@ -144,18 +155,10 @@ pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
     // faltten the matrix
     let flat_mtrx: Vec<String> = parsed_mtrx.into_iter().flatten().collect();
     // fulfill info and encrypt it
-    let info = EncptInfo {
-        original_length: buffer.len(),
-        salt_short: shrt,
-    };
-    let orgnl = cyph_info(info.original_length, 0);
-    let slt_shrt = cyph_info(info.salt_short, 1);
-    let info_vec = vec![
-        join_string(str2_string_vec(orgnl)),
-        ";".to_string(),
-        join_string(str2_string_vec(slt_shrt)),
-        "$".to_string(),
-    ];
+
+    let orgnl = cyph_info(buffer.len(), 142);
+
+    let info_vec = vec![join_string(str2_string_vec(orgnl)), "$".to_string()];
     println!(
         "{:?}",
         join_string(info_vec.to_vec()) + &join_string(flat_mtrx.to_vec())

src/encpt/mapping/mapper.rs

@@ -10,18 +10,29 @@ pub enum MpType {
     SaltMap,
 }
 
+#[derive(PartialEq)]
+pub enum DirecType {
+    FORWARD,
+    BACKWARD,
+}
 // map strings to vectors
-pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType) -> Result<Vec<&str>, &str> {
+pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType, direc: DirecType) -> Result<Vec<&str>, &str> {
     let mut result: Vec<&str> = vec![];
-    let mpp: [[&str; 3]; 85];
+    let mpp: [[&str; 3]; 62];
+    let mut fs: usize = 0;
+    let mut sc: usize = 1;
+    if direc == DirecType::BACKWARD {
+        fs = 1;
+        sc = 0
+    }
     match mpt {
         MpType::CharMap => mpp = CHAR_MAP,
         MpType::SaltMap => mpp = SALT_MAP,
     }
     for e in &vc {
         for s in mpp {
-            if e == &s[0] {
-                result.push(s[1]);
+            if e == &s[fs] {
+                result.push(s[sc]);
             }
         }
     }
@@ -32,30 +43,19 @@ pub fn chr_to_mp(vc: Vec<&str>, mpt: MpType) -> Result<Vec<&str>, &str> {
     }
 }
 
-pub fn chr_to_mxas(vc: Vec<&str>) -> Result<Vec<&str>, &str> {
+pub fn chr_to_mxas(vc: Vec<&str>, direc: DirecType) -> Result<Vec<&str>, &str> {
     let mut result: Vec<&str> = vec![];
-
-    for e in &vc {
-        for s in CHAR_MAP {
-            if e == &s[0] {
-                result.push(s[2]);
-            }
-        }
-    }
-    if result.len() != vc.len() {
-        Err("CharError: unrecognized char")
-    } else {
-        Ok(result)
+    let mut fs: usize = 0;
+    let mut sc: usize = 2;
+    if direc == DirecType::BACKWARD {
+        fs = 2;
+        sc = 0
     }
-}
-
-pub fn mxas_to_chars(vc: Vec<&str>) -> Result<Vec<&str>, &str> {
-    let mut result: Vec<&str> = vec![];
-
     for e in &vc {
         for s in CHAR_MAP {
-            if e == &s[2] {
-                result.push(s[0]);
+            if e == &s[fs] {
+                println!("{}", e);
+                result.push(s[sc]);
             }
         }
     }
@@ -65,6 +65,7 @@ pub fn mxas_to_chars(vc: Vec<&str>) -> Result<Vec<&str>, &str> {
         Ok(result)
     }
 }
+
 // extend salt based on string length
 #[derive(Debug)]
 struct EmptyValueError;
@@ -115,7 +116,7 @@ pub fn salt_extender(salt: &str, password: &str) -> Result<String, Box<dyn Error
         return Ok(res.ext_data());
     }
 
-    Ok(salt.to_string())
+    Ok(password.to_string())
 }
 
 #[cfg(test)]
@@ -124,7 +125,7 @@ mod tests {
 
     #[test]
     fn try_char() {
-        let res = chr_to_mp(vec!["A", "B", "C"], MpType::CharMap);
+        let res = chr_to_mp(vec!["A", "B", "C"], MpType::CharMap, DirecType::FORWARD);
         assert_eq!(res, Ok(vec!["Aj", "bQ", "TG"]))
     }
     #[test]
@@ -182,7 +183,7 @@ mod tests {
     #[test]
     fn chr_to_mxas_test() {
         let charvc = vec!["A", "v", "b", "Q", "T", "G"];
-        let res = chr_to_mxas(charvc);
+        let res = chr_to_mxas(charvc, DirecType::FORWARD);
         assert_eq!(res, Ok(vec!["671", "258", "421", "652", "790", "487"]))
     }
 }