Enable multi-level decodings to actually work (Caesar) in multi-level paths

src/decoders/atbash_decoder.rs

@@ -45,7 +45,7 @@ impl Crack for Decoder<AtbashDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -86,7 +86,7 @@ mod tests {
     fn test_atbash() {
         let decoder = Decoder::<AtbashDecoder>::new();
         let result = decoder.crack("svool dliow", &get_athena_checker());
-        assert_eq!(result.unencrypted_text.unwrap(), "hello world");
+        assert_eq!(result.unencrypted_text.unwrap()[0], "hello world");
     }
 
     #[test]
@@ -97,7 +97,7 @@ mod tests {
             &get_athena_checker(),
         );
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "Atbash Should Keep Capitalization like THIS"
         );
     }
@@ -110,7 +110,7 @@ mod tests {
             &get_athena_checker(),
         );
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "Atbash should leave characters like these: ',.39=_#%^ intact after decoding!"
         );
     }

src/decoders/base32_decoder.rs

@@ -29,7 +29,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base32.crack("NBSWY3DPEB3W64TMMQ======", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base32Decoder;
 
@@ -72,7 +72,7 @@ impl Crack for Decoder<Base32Decoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -116,7 +116,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base32");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base58_bitcoin_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base58_bitcoin.crack("StV1DL6CwTryKyV", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base58BitcoinDecoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base58BitcoinDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -118,7 +118,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base58_bitcoin");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base58_flickr_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base58_flickr.crack("rTu1dk6cWsRYjYu", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base58FlickrDecoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base58FlickrDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -118,7 +118,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base58_flickr");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base58_monero_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base58_monero.crack("StV1DL6CwTryKyV", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base58MoneroDecoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base58MoneroDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -118,7 +118,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base58_monero");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base58_ripple_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base58_ripple.crack("StVrDLaUATiyKyV", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base58RippleDecoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base58RippleDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -118,7 +118,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base58_ripple");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base64_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base64.crack("aGVsbG8gd29ybGQ=", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello world");
+/// assert_eq!(result.unwrap()[0], "hello world");
 /// ```
 pub struct Base64Decoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base64Decoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -114,7 +114,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for base64");
-        assert_eq!(decoded_str, "hello world");
+        assert_eq!(decoded_str[0], "hello world");
     }
 
     #[test]

src/decoders/base64_url_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base64_url.crack("aHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS8_ZXhhbXBsZT10ZXN0", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "https://www.google.com/?example=test");
+/// assert_eq!(result.unwrap()[0], "https://www.google.com/?example=test");
 /// ```
 pub struct Base64URLDecoder;
 
@@ -71,7 +71,7 @@ impl Crack for Decoder<Base64URLDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -116,7 +116,7 @@ mod tests {
             &get_athena_checker(),
         );
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "https://www.google.com/?example=test"
         );
     }
@@ -131,7 +131,7 @@ mod tests {
             &get_athena_checker(),
         );
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "This is decodable by both Base64 and Base64 URL"
         );
     }

src/decoders/base65536_decoder.rs

@@ -28,7 +28,7 @@ use log::{debug, info, trace};
 ///
 /// let result = decode_base65536.crack("𒅓鹨𖡮𒀠啦ꍢ顡啫𓍱𓁡𠁴唬𓍪鱤啥𖥭𔐠𔕯ᔮ", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "Sphinx of black quartz, judge my vow.");
+/// assert_eq!(result.unwrap()[0], "Sphinx of black quartz, judge my vow.");
 /// ```
 pub struct Base65536Decoder;
 
@@ -73,7 +73,7 @@ impl Crack for Decoder<Base65536Decoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -115,7 +115,7 @@ mod tests {
         let base65536_decoder = Decoder::<Base65536Decoder>::new();
         let result = base65536_decoder.crack("𒅓鹨𖡮𒀠啦ꍢ顡啫𓍱𓁡𠁴唬𓍪鱤啥𖥭𔐠𔕯ᔮ", &get_athena_checker());
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "Sphinx of black quartz, judge my vow."
         );
     }

src/decoders/caesar_decoder.rs

@@ -28,7 +28,9 @@ use log::{info, trace};
 ///
 /// let result = decode_caesar.crack("uryyb guvf vf ybat grkg", &checker).unencrypted_text;
 /// assert!(result.is_some());
-/// assert_eq!(result.unwrap(), "hello this is long text");
+/// // If it succeeds, the 0th element is the plaintext else it'll contain 25 elements
+/// // of unsuccessfully decoded text
+/// assert_eq!(result.unwrap()[0], "hello this is long text");
 /// ```
 pub struct CaesarDecoder;
 
@@ -54,8 +56,10 @@ impl Crack for Decoder<CaesarDecoder> {
     fn crack(&self, text: &str, checker: &CheckerTypes) -> CrackResult {
         trace!("Trying Caesar Cipher with text {:?}", text);
         let mut results = CrackResult::new(self, text.to_string());
+        let mut decoded_strings = Vec::new();
         for shift in 1..25 {
             let decoded_text = caesar(text, shift);
+            decoded_strings.push(decoded_text.clone());
             if !check_string_success(&decoded_text, text) {
                 info!(
                     "Failed to decode caesar because check_string_success returned false on string {}. This means the string is 'funny' as it wasn't modified.",
@@ -67,11 +71,12 @@ impl Crack for Decoder<CaesarDecoder> {
             // If checkers return true, exit early with the correct result
             if checker_result.is_identified {
                 trace!("Found a match with caesar shift {}", shift);
-                results.unencrypted_text = Some(decoded_text);
+                results.unencrypted_text = Some(vec![decoded_text]);
                 results.update_checker(&checker_result);
                 return results;
             }
         }
+        results.unencrypted_text = Some(decoded_strings);
         results
     }
 }
@@ -134,7 +139,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for caesar");
-        assert_eq!(decoded_str, "attack");
+        assert_eq!(decoded_str[0], "attack");
     }
 
     #[test]
@@ -145,7 +150,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for caesar");
-        assert_eq!(decoded_str, "hello this is long text");
+        assert_eq!(decoded_str[0], "hello this is long text");
     }
 
     #[test]
@@ -156,7 +161,7 @@ mod tests {
         let decoded_str = &result
             .unencrypted_text
             .expect("No unencrypted text for caesar");
-        assert_eq!(decoded_str, "Hello! this is long text?");
+        assert_eq!(decoded_str[0], "Hello! this is long text?");
     }
 
     #[test]

src/decoders/citrix_ctx1_decoder.rs

@@ -65,7 +65,7 @@ impl Crack for Decoder<CitrixCTX1Decoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -129,7 +129,7 @@ mod tests {
             "MNGIKIANMEGBKIANMHGCOHECJADFPPFKINCIOBEEIFCA",
             &get_athena_checker(),
         );
-        assert_eq!(result.unencrypted_text.unwrap(), "hello world");
+        assert_eq!(result.unencrypted_text.unwrap()[0], "hello world");
     }
 
     #[test]
@@ -141,7 +141,7 @@ mod tests {
             &get_athena_checker(),
         );
         assert_eq!(
-            result.unencrypted_text.unwrap(),
+            result.unencrypted_text.unwrap()[0],
             "This is lowercase Citrix CTX1"
         );
     }
@@ -198,6 +198,6 @@ mod tests {
         // This tests if Citrix CTX1 can decode an emoji
         let citrix_ctx1_decoder = Decoder::<CitrixCTX1Decoder>::new();
         let result = citrix_ctx1_decoder.crack("😂", &get_athena_checker());
-        assert_eq!(result.unencrypted_text.unwrap(), "[*");
+        assert_eq!(result.unencrypted_text.unwrap()[0], "[*");
     }
 }

src/decoders/crack_results.rs

@@ -15,7 +15,7 @@ pub struct CrackResult {
     pub encrypted_text: String,
     /// Unencrypted text is what it looks like after.
     /// if decoder failed, this will be None
-    pub unencrypted_text: Option<String>,
+    pub unencrypted_text: Option<Vec<String>>,
     /// Decoder is the function we used to decode the text
     pub decoder: &'static str,
     /// Checker which identified the text

src/decoders/morse_code.rs

@@ -54,7 +54,7 @@ impl Crack for Decoder<MorseCodeDecoder> {
         }
 
         let checker_result = checker.check(&decoded_text);
-        results.unencrypted_text = Some(decoded_text);
+        results.unencrypted_text = Some(vec![decoded_text]);
 
         results.update_checker(&checker_result);
 
@@ -148,6 +148,6 @@ mod tests {
             ".---- ----. ..--- .-.-.- .---- -.... ---.. .-.-.- ----- .-.-.- .----",
             &get_athena_checker(),
         );
-        assert_eq!(result.unencrypted_text.unwrap(), "192.168.0.1");
+        assert_eq!(result.unencrypted_text.unwrap()[0], "192.168.0.1");
     }
 }