Added function to make initial permutation of the 64 bit message and also modified the split_keys function to support 64 bit keys.

Author: Ion Ostafi

src/main.rs

@@ -9,10 +9,8 @@ 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);
-    }
+    let subkey_pairs = create_16_subkeys(left, right);
+    let subkeys_48_bit = convert_pairs_to_encrypted_48_bit_keys(subkey_pairs);
     //println!("{:b}\n{:b}", left, right);
 }
 
@@ -39,9 +37,10 @@ pub fn generate_key_plus(key: i64) -> i64 {
 }
 
 
-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;
+pub fn split_key(key : i64, key_len: u8) -> (i64, i64) {
+    let half_size = key_len / 2;
+    let left_half = (key >> half_size) & bit_pattern_containing_ones(half_size);
+    let right_half = key & bit_pattern_containing_ones(half_size);
     (left_half,right_half)
 }
 
@@ -95,5 +94,33 @@ pub fn key_kn_from_pair(left: i64, right: i64) -> i64 {
 
 
 pub fn convert_pairs_to_encrypted_48_bit_keys(pairs: Vec<(i64, i64)>) -> Vec<i64> {
-    Vec::new()
+    let mut keys_48_bit : Vec<i64> = Vec::new();
+    for idx in 0..pairs.len() {
+        keys_48_bit.push(key_kn_from_pair(pairs[idx].0, pairs[idx].1));
+    }
+    keys_48_bit
+}
+
+
+
+//Step 2: Encode each 64-bit block of data.
+const IP : [u8; 64] = [
+58, 50,42, 34, 26,18, 10, 2,
+60, 52,44, 36, 28,20, 12, 4,
+62, 54,46, 38, 30,22, 14, 6,
+64, 56,48, 40, 32,24, 16, 8,
+57, 49,41, 33, 25,17,  9, 1,
+59, 51,43, 35, 27,19, 11, 3,
+61, 53,45, 37, 29,21, 13, 5,
+63, 55,47, 39, 31,23, 15, 7
+];
+//b = bit
+pub fn initial_permutation_of_64bit_message(message : i64) -> i64 {
+    let mut permutation = 0i64;
+    for idx in 0..64 {
+        let bit_at_index_in_message = (message >> (64 - IP[idx])) & 1;
+        permutation = permutation << 1;
+        permutation = permutation | bit_at_index_in_message;
+    }
+    permutation
 }

src/main_tests.rs

@@ -109,3 +109,46 @@ fn creating_48_bit_key_based_on_maximum_pairs() {
     let expected = 0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111;
     assert_eq!(expected, key_kn_from_pair(left, right));
 }
+
+
+#[test]
+fn get_48_bit_keys_from_array_of_28_bit_pairs() {
+    let pairs_28_bit = vec![(0b1110000110011001010101011111,0b1010101011001100111100011110),
+    (0b1100001100110010101010111111,0b0101010110011001111000111101),
+    (0b0000110011001010101011111111,0b0101011001100111100011110101),
+    (0b0011001100101010101111111100,0b0101100110011110001111010101),
+
+    (0b1100110010101010111111110000,0b0110011001111000111101010101),
+    (0b0011001010101011111111000011,0b1001100111100011110101010101),
+    (0b1100101010101111111100001100,0b0110011110001111010101010110),
+    (0b0010101010111111110000110011,0b1001111000111101010101011001)];
+
+    let expected = vec![0b000110110000001011101111111111000111000001110010,
+    0b011110011010111011011001110110111100100111100101,
+    0b010101011111110010001010010000101100111110011001,
+    0b011100101010110111010110110110110011010100011101,
+    0b011111001110110000000111111010110101001110101000,
+    0b011000111010010100111110010100000111101100101111,
+    0b111011001000010010110111111101100001100010111100,
+    0b111101111000101000111010110000010011101111111011];
+
+    assert_eq!(expected, convert_pairs_to_encrypted_48_bit_keys(pairs_28_bit));
+}
+
+
+
+#[test]
+fn permutation_of_64bit_integer_gives_58_bit() {
+    let message_64bit = 0x123456789abcdef;
+    let intial_permutation = 0xcc00ccfff0aaf0aa;
+    assert_eq!(intial_permutation, initial_permutation_of_64bit_message(message_64bit));
+}
+
+
+#[test]
+fn splitting_key_of_64_bit_into_32_bit_pair() {
+    let key =  0xcc00ccfff0aaf0aa;
+    let left = 0xcc00ccffi64;
+    let right = 0xf0aaf0aai64;
+    assert_eq!((left, right), split_key(key, 64));
+}