From 7bcccede3eaa3d2ef01aa274e46f27e1673a1f21 Mon Sep 17 00:00:00 2001
From: Jesse Luehrs <doy@tozt.net>
Date: Fri, 3 Apr 2015 20:33:25 -0400
Subject: refactor to allow specifying the keysize

---
 src/crack.rs | 60 ++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 32 insertions(+), 28 deletions(-)

(limited to 'src')

diff --git a/src/crack.rs b/src/crack.rs
index 523c7e8..344488b 100644
--- a/src/crack.rs
+++ b/src/crack.rs
@@ -71,38 +71,14 @@ pub fn crack_repeating_key_xor (input: &[u8]) -> Vec<u8> {
     let mut min_diff = 100.0;
     let mut best_key = vec![];
     for (keysize, _) in keysizes {
-        let strides: Vec<Vec<u8>> = (0..keysize)
-            .map(|n| {
-                // XXX sigh ):
-                let mut elts = vec![];
-                for (i, &c) in input.iter().enumerate() {
-                    if i % keysize == n {
-                        elts.push(c);
-                    }
-                }
-                elts
-            })
-            .collect();
-        let cracked: Vec<(u8, f64)> = strides
-            .iter()
-            .map(|input| crack_single_byte_xor_with_confidence(input))
-            .collect();
-        let diff = cracked
-            .iter()
-            .map(|&(_, diff)| diff)
-            .fold(0.0, |acc, x| acc + x);
-        let key = cracked
-            .iter()
-            .map(|&(c, _)| c)
-            .collect();
-        let normal_diff = diff / (keysize as f64);
-        if normal_diff < min_diff {
-            min_diff = normal_diff;
+        let (key, diff) = crack_repeating_key_xor_with_keysize(input, keysize);
+        if diff < min_diff {
+            min_diff = diff;
             best_key = key;
         }
     }
 
-    return repeating_key_xor(input, &best_key[..]);
+    return best_key;
 }
 
 pub fn find_aes_128_ecb_encrypted_string (inputs: &[Vec<u8>]) -> Vec<u8> {
@@ -378,6 +354,34 @@ fn crack_single_byte_xor_with_confidence (input: &[u8]) -> (u8, f64) {
     return (best_key, min_diff);
 }
 
+fn crack_repeating_key_xor_with_keysize (input: &[u8], keysize: usize) -> (Vec<u8>, f64) {
+    let strides: Vec<Vec<u8>> = (0..keysize)
+        .map(|n| {
+            // XXX sigh ):
+            let mut elts = vec![];
+            for (i, &c) in input.iter().enumerate() {
+                if i % keysize == n {
+                    elts.push(c);
+                }
+            }
+            elts
+        })
+        .collect();
+    let cracked: Vec<(u8, f64)> = strides
+        .iter()
+        .map(|input| crack_single_byte_xor_with_confidence(input))
+        .collect();
+    let diff = cracked
+        .iter()
+        .map(|&(_, diff)| diff)
+        .fold(0.0, |acc, x| acc + x);
+    let key = cracked
+        .iter()
+        .map(|&(c, _)| c)
+        .collect();
+    return (key, diff / (keysize as f64));
+}
+
 fn count_duplicate_blocks (input: &[u8], block_size: usize) -> usize {
     let mut set = HashSet::new();
     let mut dups = 0;
-- 
cgit v1.2.3-54-g00ecf