Added functions to calculate pair keys and also tested it intensively

Author: BProg

.gitignore

@@ -0,0 +1 @@
+target

Cargo.lock

@@ -0,0 +1,15 @@
+[package]
+name = "des_cipher"
+version = "0.1.0"
+authors = ["Scientist <ostafi_ion@yahoo.com>"]
+
+
+
+[profile.dev]
+opt-level = 0  # Controls the --opt-level the compiler builds with
+debug = true   # Controls whether the compiler passes `-g`
+rpath = false  # Controls whether the compiler passes `-C rpath`
+lto = false    # Controls `-C lto` for binaries and staticlibs
+debug-assertions = true  # Controls whether debug assertions are enabled
+codegen-units = 1 # Controls whether the compiler passes `-C codegen-units`
+                  # `codegen-units` is ignored when `lto = true'

Cargo.toml

@@ -0,0 +1,87 @@
+#[cfg(test)]
+mod main_tests;
+
+//const MESS : i64 = 0x0123456789ABCDEF;
+const KEY : i64 = 0x133457799BBCDFF1;
+
+
+
+fn main() {
+    let key_plus = generate_key_plus(KEY);
+    let (left, right) = split_key(key_plus, 56);
+    let subkeys = create_16_subkeys(left, right);
+    for idx in 0..subkeys.len() {
+        println!("[{0}]{1:b}\n[{0}]{2:b}\n\n",idx, subkeys[idx].0, subkeys[idx].1);
+    }
+    //println!("{:b}\n{:b}", left, right);
+}
+
+
+//Step 1: Create 16 subkeys, each of which is 48-bits long.
+const PC1 : [u8; 56] =
+[57, 49, 41, 33, 25, 17, 9, 1,
+58, 50, 42, 34, 26, 18, 10, 2,
+59, 51, 43, 35, 27, 19, 11, 3,
+60, 52, 44, 36, 63, 55, 47, 39,
+31, 23, 15, 7, 62, 54, 46, 38,
+30, 22, 14, 6, 61, 53, 45, 37,
+29, 21, 13, 5, 28, 20, 12, 4];
+
+
+pub fn generate_key_plus(key: i64) -> i64 {
+    let mut key_plus : i64 = 0;
+    for idx in 0..56 {
+        let bit_to_add = key >> (64 - PC1[idx]) & 1;
+        key_plus = key_plus << 1;
+        key_plus = key_plus | bit_to_add;
+    }
+    key_plus
+}
+
+
+pub fn split_key(key : i64, key_len: i8) -> (i64, i64) {
+    let left_half = key >> key_len / 2;
+    let right_half = (key << 64 - key_len + key_len / 2) >> 64 - key_len + key_len / 2;
+    (left_half,right_half)
+}
+
+
+const LEFT_SHIFTS : [u8; 16] = [1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1];
+
+pub fn create_16_subkeys(left_half: i64, right_half: i64) -> Vec<(i64, i64)> {
+    let mut subkeys : Vec<(i64, i64)> = Vec::new();
+    subkeys.push((left_half, right_half));
+    for idx in 0..16 {
+        let next_left = bit_rotate_left(subkeys[idx].0, LEFT_SHIFTS[idx]);
+        let next_right = bit_rotate_left(subkeys[idx].1, LEFT_SHIFTS[idx]);
+        subkeys.push((next_left, next_right));
+    }
+    subkeys.remove(0);
+    subkeys
+}
+
+pub fn bit_rotate_left(bit_array : i64, rol_count : u8) -> i64 {
+    let rotated_bit = ((bit_pattern_containing_ones(rol_count) << 28 - rol_count) & bit_array) >> 28 - rol_count;
+    ((bit_array << rol_count) & 0xffff_fff) | rotated_bit
+}
+
+
+pub fn bit_pattern_containing_ones(how_much: u8) -> i64 {
+    ((2u64).pow(how_much as u32) - 1) as i64
+}
+
+
+const PC2 : [u8; 48] =
+[14, 17, 11, 24, 1, 5,
+  3, 28, 15, 6, 21, 10,
+ 23, 19, 12, 4, 26, 8,
+ 16, 7, 27, 20, 13, 2,
+ 41, 52, 31, 37, 47, 55,
+ 30, 40, 51, 45, 33, 48,
+ 44, 49, 39, 56, 34, 53,
+ 46, 42, 50, 36, 29, 32];
+
+
+pub fn key_kn_from_pair(left: i64, right: i64) -> i64 {
+    0
+}

src/main.rs

@@ -0,0 +1,102 @@
+use super::*;
+
+
+#[test]
+fn rotatig_bit_with_1_on_firstbit() {
+    let bit_to_rotate : i64 = 0b1111000011110000111100001111;
+    assert_eq!(0b1110000111100001111000011111, bit_rotate_left(bit_to_rotate, 1));
+}
+
+
+#[test]
+fn rotatig_bit_with_2_positions() {
+    let bit_to_rotate : i64 = 0b1111_0000_1111_0000_1111_0000_1111;
+    assert_eq!(0b1100_0011_1100_0011_1100_0011_1111, bit_rotate_left(bit_to_rotate, 2));
+}
+
+
+#[test]
+fn ones_for_2_is_11() {
+    assert_eq!(0b11, bit_pattern_containing_ones(2));
+}
+
+
+#[test]
+fn creating_vector_with_keys_returns_correct_subkeys() {
+    let subkeys = create_16_subkeys(0b1111000011001100101010101111, 0b0101010101100110011110001111);
+    assert_eq!(16, subkeys.len());
+    //1
+    assert_eq!(0b1110000110011001010101011111, subkeys[0].0);
+    assert_eq!(0b1010101011001100111100011110, subkeys[0].1);
+    //2
+    assert_eq!(0b1100001100110010101010111111, subkeys[1].0);
+    assert_eq!(0b0101010110011001111000111101, subkeys[1].1);
+    //3
+    assert_eq!(0b0000110011001010101011111111, subkeys[2].0);
+    assert_eq!(0b0101011001100111100011110101, subkeys[2].1);
+    //4
+    assert_eq!(0b0011001100101010101111111100, subkeys[3].0);
+    assert_eq!(0b0101100110011110001111010101, subkeys[3].1);
+    //5
+    assert_eq!(0b1100110010101010111111110000, subkeys[4].0);
+    assert_eq!(0b0110011001111000111101010101, subkeys[4].1);
+    //6
+    assert_eq!(0b0011001010101011111111000011, subkeys[5].0);
+    assert_eq!(0b1001100111100011110101010101, subkeys[5].1);
+    //7
+    assert_eq!(0b1100101010101111111100001100, subkeys[6].0);
+    assert_eq!(0b0110011110001111010101010110, subkeys[6].1);
+    //8
+    assert_eq!(0b0010101010111111110000110011, subkeys[7].0);
+    assert_eq!(0b1001111000111101010101011001, subkeys[7].1);
+    //9
+    assert_eq!(0b0101010101111111100001100110, subkeys[8].0);
+    assert_eq!(0b0011110001111010101010110011, subkeys[8].1);
+    //10
+    assert_eq!(0b0101010111111110000110011001, subkeys[9].0);
+    assert_eq!(0b1111000111101010101011001100, subkeys[9].1);
+    //11
+    assert_eq!(0b0101011111111000011001100101, subkeys[10].0);
+    assert_eq!(0b1100011110101010101100110011, subkeys[10].1);
+    //12
+    assert_eq!(0b0101111111100001100110010101, subkeys[11].0);
+    assert_eq!(0b0001111010101010110011001111, subkeys[11].1);
+    //13
+    assert_eq!(0b0111111110000110011001010101, subkeys[12].0);
+    assert_eq!(0b0111101010101011001100111100, subkeys[12].1);
+    //14
+    assert_eq!(0b1111111000011001100101010101, subkeys[13].0);
+    assert_eq!(0b1110101010101100110011110001, subkeys[13].1);
+    //15
+    assert_eq!(0b1111100001100110010101010111, subkeys[14].0);
+    assert_eq!(0b1010101010110011001111000111, subkeys[14].1);
+    //16
+    assert_eq!(0b1111000011001100101010101111, subkeys[15].0);
+    assert_eq!(0b0101010101100110011110001111, subkeys[15].1);
+
+}
+
+
+#[test]
+fn test_spliting_a_56_bit_key_into_2_x_28_keys() {
+    let original_key = 0b11110000110011001010101011110101010101100110011110001111;
+    let expected_left = 0b1111000011001100101010101111;
+    let expected_right = 0b0101010101100110011110001111;
+    assert_eq!((expected_left, expected_right), split_key(original_key, 56));
+}
+
+
+#[test]
+fn generate_key_plus_based_on_pc1_table() {
+    let key = 0b0001001100110100010101110111100110011011101111001101111111110001;
+    let key_plus = 0b11110000110011001010101011110101010101100110011110001111;
+    assert_eq!(key_plus, generate_key_plus(key));
+}
+
+#[test]
+fn creating_key_based_on_paris_and_PC2_table() {
+    let left = 0b1110000110011001010101011111;
+    let right = 0b1010101011001100111100011110;
+    let expected_key = 0b000110110000001011101111111111000111000001110010;
+    assert_eq!(expected_key, key_kn_from_pair(left, right));
+}