Bug (decrytion): can't construct the matrix from vec because of pop

src/encpt/encrypt.rs

@@ -112,23 +112,25 @@ 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());
-
+    println!("mx version {:?}", &mx_version);
     // 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));
+    println!("the original matrix {:?}", &splitted_filled);
     // get the green, red, blue vecs from the matrix
     let vecs_from_mtrx = mtrx_to_vecs(splitted_filled);
-
+    println!("vecs from tmrx {:?}", vecs_from_mtrx);
     let grn = &vecs_from_mtrx[0];
     let rd = &vecs_from_mtrx[1];
     let ble = &vecs_from_mtrx[2];
-    println!("heeey {:?} ,{}", &rd, &mtrx_n);
+    println!("green {:?} ", &grn);
+    println!("red {:?} ", &rd);
+    println!("blue {:?} ", &ble);
     // add mtrx_n to green and blue and the red length to red
     let grn_a: Vec<String> = flt_subvecs(mtrx_n, grn.to_vec());
     let rd_a: Vec<String> = flt_subvecs(mtrx_n, rd.to_vec());
     let ble_a: Vec<String> = flt_subvecs(mtrx_n, ble.to_vec());
-    println!("{:?}", &grn_a);
     // ceaser
     let grn_swapped = ceaser_swap(grn_a.clone(), grn_a.len() + 2);
     let rd_swapped = ceaser_swap(rd_a.clone(), rd_a.len());
@@ -140,10 +142,8 @@ pub fn df1t_encrypt(buffer: String, salt: String) -> Result<String, Box<dyn Erro
             .iter()
             .map(|c| flatten_vec(c.iter().map(|&c| c.to_string()).collect()))
             .collect();
-    println!("{:?}", &parsed_mtrx);
     // faltten the matrix
     let flat_mtrx: Vec<String> = parsed_mtrx.into_iter().flatten().collect();
-    println!("flat : {:?}", &flat_mtrx);
     // fulfill info and encrypt it
     let info = EncptInfo {
         original_length: buffer.len(),

src/encpt/math/matrix.rs

@@ -39,23 +39,49 @@ pub fn mtrx_to_vecs(mtrx: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
     let mut blue: Vec<i32> = vec![];
     let mut green: Vec<i32> = vec![];
     let mut red: Vec<i32> = vec![];
-    let mut res: Vec<Vec<i32>> = vec![];
 
     for (i, element) in mtrx.iter().enumerate() {
         for (j, sub) in element.iter().enumerate() {
+            // println!("{:?} : {:?} => {:?}", i, j, sub);
             if i > j {
                 blue.push(*sub);
             } else if j > i {
+                println!("j : {:?}  => {:?}", j, sub);
                 green.push(*sub);
+                println!("{:?}", green);
             } else {
                 red.push(*sub);
             }
         }
     }
-    res.push(green);
-    res.push(red);
-    res.push(blue);
+    println!("{:?}", green);
 
+    let res: Vec<Vec<i32>> = vec![green, red, blue];
+    println!("res = {:?}", res);
+    println!("res = {:?}", res[0]);
+    res
+}
+
+pub fn vecs_to_mtrx(mtrx: Vec<Vec<i32>>) -> Vec<i32> {
+    let green = &mtrx[0];
+    let red = &mtrx[1];
+    let blue = &mtrx[2];
+    println!("grn {:?}", green);
+    println!("rd {:?}", red);
+    println!("ble {:?}", blue);
+    let mut res: Vec<i32> = vec![];
+    for (i, element) in mtrx.iter().enumerate() {
+        for (j, sub) in element.iter().enumerate() {
+            if i < j {
+                println!("poped {:?}", green.to_vec().remove(0));
+                res.push(green.to_vec().remove(0));
+            } else if j < i {
+                res.push(blue.to_vec().remove(0));
+            } else {
+                res.push(red.to_vec().remove(0));
+            }
+        }
+    }
     res
 }
 
@@ -90,4 +116,24 @@ mod tests {
         let res = calc_n(e);
         assert_eq!(res, 5);
     }
+
+    #[test]
+    fn test_rvrs_vec_to_mtrx() {
+        let mtrx = vec![
+            vec![165, 314, 671, 113, 923, 314, 194, 422, 652, 422],
+            vec![652, 389, 652, 422, 103, 0],
+            vec![
+                103, 258, 716, 103, 389, 113, 652, 194, 113, 422, 0, 0, 0, 0, 0,
+            ],
+        ];
+
+        let expected = vec![
+            652, 165, 314, 671, 113, 422, 103, 923, 314, 194, 113, 389, 314, 422, 652, 923, 113,
+            194, 103, 422, 652, 389, 0, 0, 0,
+        ];
+
+        let res = vecs_to_mtrx(mtrx.clone());
+        // vecs_to_mtrx(mtrx);
+        assert_eq!(res, expected);
+    }
 }

src/main.rs

@@ -63,11 +63,17 @@ fn main() {
     //     println!("{:?}", d);
     // }
     // Example usage
-    let salt = "sqdfqfgsffdqsdf";
-    let password = "radqsfdfdfdqsdf";
+    let salt = "sqdfqdqsdf";
+    let password = "radqsfdqsdf";
     let res = df1t_encrypt(password.to_owned(), salt.to_owned());
 
-    let saltt = "sqdfqfgsffdqsdf";
+    let saltt = "sqdfqdqsdf";
     let res1 = df1t_decrypt(res.unwrap().to_owned(), saltt.to_owned());
     println!("{}", res1.unwrap())
 }
+
+//[[652, 165, 314, 671, 113],
+// [422, 103, 923, 314, 194],
+// [113, 389, 314, 422, 652],
+// [923, 113, 194, 103, 422],
+// [652, 389, 000, 000, 000]]