Work out operators and key/message derivation

src/main.rs

@@ -0,0 +1,115 @@
+// Angefangen: 13:30
+// bis: 16:20
+//
+
+use clap::Parser;
+use clap_num::maybe_hex;
+
+#[derive(Parser)]
+struct Cli {
+    // The message to be encrypted
+    #[arg(short = 'm', long = "message", value_parser=maybe_hex::<u64>, default_value_t = 0x42)]
+    message: u64,
+    // the key used for encryption/decryption
+    #[arg(short = 'k', long = "key", value_parser=maybe_hex::<u128>, default_value_t = 123456789012345678901234567890)]
+    key: u128,
+}
+
+struct Vr {
+    v1: u16,
+    v2: u16,
+    v3: u16,
+    v4: u16,
+}
+
+impl Vr {
+    fn split(v: u64) -> Self {
+        let v4 = (v & 0xFFFF) as u16;
+        let v3 = ((v >> 16) & 0xFFFF) as u16;
+        let v2 = ((v >> 32) & 0xFFFF) as u16;
+        let v1 = ((v >> 48) & 0xFFFF) as u16;
+        Self{ v1: v1, v2: v2, v3: v3, v4: v4 }
+    }
+
+    fn expand(&self) -> u64 {
+        (self.v1 as u64 * 2_u64.pow(48)) + (self.v2 as u64 * 2_u64.pow(32)) + (self.v3 as u64 * 2_u64.pow(16)) + self.v4 as u64
+    }
+}
+
+struct Keys {
+    z1: u16, z2: u16, z3: u16, z4: u16, z5: u16, z6: u16,
+}
+
+
+fn derive_keys(mut k: u128) -> Vec<Keys> {
+    let mut keys: Vec<Keys> = Vec::new();
+
+    let mut subkeys = Vec::new();
+    while subkeys.len() < 52 {
+        subkeys.push((k & 0xFFFF) as u16);
+        subkeys.push(((k >> 16) & 0xFFFF) as u16);
+        subkeys.push(((k >> 32) & 0xFFFF) as u16);
+        subkeys.push(((k >> 48) & 0xFFFF) as u16);
+        subkeys.push(((k >> 64) & 0xFFFF) as u16);
+        subkeys.push(((k >> 80) & 0xFFFF) as u16);
+        subkeys.push(((k >> 96) & 0xFFFF) as u16);
+        subkeys.push(((k >> 112) & 0xFFFF) as u16);
+        k = k.rotate_left(25);  
+        println!("key after shift {k}");
+    }
+    let mut i = 0;
+    while keys.len() < 8 {
+    keys.push(
+       Keys{ z1: subkeys[0+i], z2: subkeys[1+i], z3: subkeys[2+i], z4: subkeys[3+i], z5: subkeys[4+i], z6: subkeys[5+i] } 
+    );
+        i = i+1;
+    }
+    keys.push(
+       Keys{ z1: subkeys[0+i], z2: subkeys[1+i], z3: subkeys[2+i], z4: subkeys[3+i], z5: 0, z6: 0 } 
+    );
+    keys
+}
+
+fn add(a: u16, b: u16) -> u16 {
+    let (a, b, m) = (a as u32, b as u32, 0x10000 as u32);
+    ((a * b) % m) as u16
+}
+
+fn mul(a: u16, b: u16) -> u16 {
+    let (a, b, m) = (a as u32, b as u32, 0x10001 as u32);
+    if a == 0 {
+        let a = 0x10000;
+        ((a * b) % m) as u16
+    }
+    else if b == 0 {
+        let b = 0x10000;
+        ((a * b) % m) as u16
+    }
+    else{
+        ((a * b) % m) as u16
+    }
+}
+
+fn idea_round() -> Vr {
+    Vr::split(80)    
+}
+
+fn encrypt(k: u128, m: u64) -> u64 {
+    let xr = Vr::split(m);
+    assert_eq!(m, xr.expand());
+    let round_keys = derive_keys(k);
+    mul(xr.v1, 0).into()
+}
+
+fn main() {
+    println!("Welcome to your IDEA encryption tool!");
+
+    let args = Cli::parse();
+    let key: u128 = args.key;
+    let message: u64 = args.message;
+
+    println!("message: {:?}, key: {:?}", message, key);
+
+    let cipher: u64 = encrypt(key, message);
+    println!("ciphertext: {:?}", cipher);
+}