otp.rs
| // This code can be compiled in 3 modes: | |
| // rustc --cfg find | |
| // rustc --cfg interactive | |
| // rustc --cfg oracle | |
| // | |
| // The interactive mode is based on the | |
| // crib dragging technique described by | |
| // Dan Crowley at: | |
| // https://www.trustwave.com/Resources/SpiderLabs-Blog/The-Way-of-the-Cryptologist/ | |
| fn code(msg: &str, key: &str, encode: bool) -> String { | |
| use std::ascii::AsciiExt; | |
| assert!(msg.is_ascii()); | |
| assert!(key.is_ascii()); | |
| let len = std::cmp::min(msg.len(), key.len()); | |
| let mut result = String::with_capacity(len); | |
| // Convery lowercase -> uppercase and everything else to space | |
| // Then encode 'A'..'Z' => '1'..'26' and ' ' => 0 | |
| let normalize = |x| match x { | |
| b'a'...b'z' => (x - 32) as i8 - b'A' as i8 + 1, | |
| b'A'...b'Z' => x as i8 - b'A' as i8 + 1, | |
| _ => 0 | |
| }; | |
| // % does not have the semantics we want for negative values | |
| let modulus = |a, b| ((a % b) + b) % b; | |
| for (k, m) in key.bytes().zip(msg.bytes()) { | |
| let (k, m) = (normalize(k), normalize(m)); | |
| // Either encode or decode | |
| let c = if encode { m + k } else { m - k }; | |
| // Gotta make sure we keep to A-Z | |
| let c = modulus(c, 27); | |
| // And back to ASCII | |
| let c = if c == 0 { b' ' } else { c as u8 + b'A' - 1 }; | |
| result.push(c as char); | |
| } | |
| result | |
| } | |
| #[cfg(interactive)] | |
| #[allow(unused_must_use)] | |
| fn main() { | |
| use std::io::{self, Write}; | |
| use std::iter; | |
| let c1 = include_str!("enc1.txt").trim_right_matches('\n'); | |
| let c2 = include_str!("enc2.txt").trim_right_matches('\n'); | |
| let diff = code(c1, c2, false); | |
| println!("c1 - c2 = m1 - m2:\n{}\n", diff); | |
| if let Some(pos) = diff.find("LIKELY") { | |
| println!("LIKELY Position: {}", pos); | |
| println!(" c1 \t {}", &c1[pos-1..pos+7]); | |
| println!(" c2 \t {}", &c2[pos-1..pos+7]); | |
| println!("c1-c2 \t {}", &diff[pos-1..pos+7]); | |
| } | |
| let stdout = io::stdout(); | |
| let mut out = stdout.lock(); | |
| let mut m1: String = iter::repeat('_').take(diff.len()).collect(); | |
| let mut m2: String = iter::repeat('_').take(diff.len()).collect(); | |
| let mut key: String = iter::repeat('_').take(diff.len()).collect(); | |
| let mut crib = String::new(); | |
| let mut res = String::new(); | |
| 'repl: loop { | |
| crib.clear(); | |
| res.clear(); | |
| write!(out, "Msg 1:\t{}\n\nMsg 2:\t{}\n\nKey:\t{}\n\n", m1, m2, key); | |
| write!(out, "Crib: "); | |
| out.flush(); | |
| if let Err(e) = io::stdin().read_line(&mut crib) { | |
| panic!("Error reading crib: {}", e); | |
| } | |
| crib = crib.trim_right_matches('\n').to_string(); | |
| let run = diff.len() - crib.len() + 1; | |
| for i in 0..run { | |
| write!(out, "[{}]: >{}< >{}<\n", i, code(&diff[i..], &crib, true), code(&crib, &diff[i..], false)); | |
| } | |
| 'resp: loop { | |
| write!(out, "\nSelect [i], 'none' or 'quit'? "); | |
| out.flush(); | |
| if let Err(e) = io::stdin().read_line(&mut res) { | |
| panic!("Error reading response: {}", e); | |
| } | |
| if res.trim() == "quit" || res.trim() == "q" { | |
| break 'repl; | |
| } else if res.trim() == "none" || res.trim() == "n" { | |
| break 'resp; | |
| } else { | |
| match res.trim().parse::<usize>() { | |
| Ok(i) if i < diff.len() => { | |
| let mut which = String::new(); | |
| write!(out, "Crib part of message [1] or [2]? "); | |
| out.flush(); | |
| if let Err(e) = io::stdin().read_line(&mut which) { | |
| panic!("Error reading message selection: {}", e); | |
| } | |
| let loc1 = (&mut m1[i..i + crib.len()]).as_ptr() as *mut _; | |
| let loc2 = (&mut m2[i..i + crib.len()]).as_ptr() as *mut _; | |
| let k = if which.trim() == "1" { | |
| let m2 = code(&crib, &diff[i..], false); | |
| unsafe { | |
| std::intrinsics::copy(crib.as_ptr(), loc1, m2.len()); | |
| std::intrinsics::copy(m2.as_ptr(), loc2, m2.len()); | |
| } | |
| code(&c2[i..], &m2, false) | |
| } else if which.trim() == "2" { | |
| let m1 = code(&diff[i..], &crib, true); | |
| unsafe { | |
| std::intrinsics::copy(m1.as_ptr(), loc1, m1.len()); | |
| std::intrinsics::copy(crib.as_ptr(), loc2, m1.len()); | |
| } | |
| code(&c1[i..], &m1, false) | |
| } else { | |
| break 'resp; | |
| }; | |
| unsafe { | |
| let loc = (&mut key[i..i + crib.len()]).as_ptr() as *mut _; | |
| std::intrinsics::copy(k.as_ptr(), loc, k.len()); | |
| } | |
| break 'resp; | |
| } | |
| _ => { | |
| write!(out, "Invalid entry.\n"); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| #[cfg(find)] | |
| fn main() { | |
| let words = include_str!("1000.dicin"); | |
| let c1 = include_str!("enc1.txt").trim_right_matches('\n'); | |
| let c2 = include_str!("enc2.txt").trim_right_matches('\n'); | |
| let diff = code(c1, c2, false); | |
| for w in words.lines() { | |
| let mut word = "LIKELY ".to_string(); | |
| word.push_str(w.trim_right_matches('\n')); | |
| // m1 - (c1 - c2) | |
| // = m1 - ((m1 + k) - (m2 + k)) | |
| // = m1 - (m1 + k - m2 - k) | |
| // = m1 - (m1 - m2) | |
| // = m1 - m1 + m2 | |
| // = m2 | |
| let c = code(&word, &diff[2641..2641+word.len()], false); | |
| println!("{} - {}", word, c.trim()); | |
| } | |
| } | |
| #[cfg(oracle)] | |
| fn main() { | |
| use std::io::{self, Write}; | |
| let stdout = io::stdout(); | |
| let mut handle = stdout.lock(); | |
| write!(handle, "Key: ").unwrap(); | |
| handle.flush().unwrap(); | |
| let mut key = String::new(); | |
| if let Err(e) = io::stdin().read_line(&mut key) { | |
| panic!("Error reading key: {}", e); | |
| } | |
| write!(handle, "Msg: ").unwrap(); | |
| handle.flush().unwrap(); | |
| let mut msg = String::new(); | |
| if let Err(e) = io::stdin().read_line(&mut msg) { | |
| panic!("Error reading msg: {}", e); | |
| } | |
| write!(handle, "[D]ecode or [E]ncode? ").unwrap(); | |
| handle.flush().unwrap(); | |
| let mut action = String::new(); | |
| if let Err(e) = io::stdin().read_line(&mut action) { | |
| panic!("Error reading action: {}", e); | |
| } | |
| if !action.starts_with("D") && | |
| !action.starts_with("E") { | |
| panic!("Plz."); | |
| } | |
| let c = code(msg.trim_right_matches('\n'), | |
| key.trim_right_matches('\n'), | |
| action.starts_with("E")); | |
| println!("Result:\n{}", c); | |
| } |