Struct DES_Generic

Source

pub struct DES_Generic {}

Expand description

des.rs may be too big because of documentation and plenty of examples. So, in order to provide documentation without docs.rs’s failing generating documentation, dummy codes were made and documentation and examples were moved to des_basic.rs.

Implementations§

Source §

impl DES_Generic

des.rs may be too big because of documentation and plenty of examples. So, in order to provide documentation without docs.rs’s failing generating documentation, dummy codes were made and documentation and examples were moved to des_basic.rs. And, most of generic parameters are omitted. It is not actual code but dummy code for compilation!!!

Source

pub fn new() -> Self

Constructs a new object DES_Generic.

§Features

In order to encrypt date, object should be instantiated mutable.
This method sets the key to be [0, 0, 0, 0, 0, 0, 0, 0].
Do not use this default key [0, 0, 0, 0, 0, 0, 0, 0] because it is known as one of the weak keys.

§Example 1

use cryptocol::symmetric::DES;

let mut des = DES::new();   // The default key is 0x0000000000000000 which is a weak key.
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x1E32B46B44C69201_u64);

let cipher_cipher_text = des.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);  // So, you can't use the default key!!!

§Compile-fail Example

use cryptocol::symmetric::DES;
let des = DES::new();
// It cannot be compiled!
des.encrypt_u64(0x1E32B46B44C69201_u64);

Source

pub fn new_with_key(_key: [u8; 8]) -> Self

Constructs a new object DES_Generic.

§Arguments

The argument key is the array of u8 that has 8 elements.
Remember that inverted parity bits do not affect the 56-bit real key. So, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00], [0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01], etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

This method sets the key to be the given argument key.

§Example 1 for normal case

use cryptocol::symmetric::DES;
let mut des = DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x3B6041D76AF28F23_u64);

let cipher_cipher_text = des.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x7C5AAE491DC1310D_u64);
assert_ne!(cipher_cipher_text, plaintext);

§Example 2 for Weak key case for [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]

// The key [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] is the same key as the key
// [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01] because of parity bits.

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
let mut des2 = DES::new_with_key([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext2, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
// and [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]!!!

§Example 3 for Weak key case for [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

// The key [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] is the same key as the key
// [0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE] because of parity bits.

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
let mut des2 = DES::new_with_key([0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext2, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
// and [0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE]!!!

§Example 4 for Weak key case for [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]

// The key [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1] is the same key as the key
// [0xE1, 0xE1, 0xE1, 0xE1, 0xF0, 0xF0, 0xF0, 0xF0] because of parity bits.

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]);
let mut des2 = DES::new_with_key([0xE1, 0xE1, 0xE1, 0xE1, 0xF0, 0xF0, 0xF0, 0xF0]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext2, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]
// and [0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1]!!!

§Example 5 for Weak key case for [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]

// The key [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E] is the same key as the key
// [0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F] because of parity bits.

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]);
let mut des2 = DES::new_with_key([0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext2, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]
// and [0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F]!!!

§Example 6 for Semi-Weak key case for [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E] and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E]);
let mut des2 = DES::new_with_key([0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xC2C71D736E97876C_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x063A6E55466423D2_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E]
// and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]!!!

§Example 7 for Semi-Weak key case for [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1] and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1]);
let mut des2 = DES::new_with_key([0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x85A63690E79AAA15_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x15B721BBB44A12F5_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1]
// and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]!!!

§Example 8 for Semi-Weak key case for [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE] and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]

use cryptocol::symmetric::DES;

// Semi-Weak key case 3 for
let mut des1 = DES::new_with_key([0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE]);
let mut des2 = DES::new_with_key([0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xAE38CC9D9FA48581_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x7EE95658A653960D_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE]
// and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]!!!

§Example 9 for Semi-Weak key case for [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1] and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]

use cryptocol::symmetric::DES;

// Semi-Weak key case 4 for
let mut des1 = DES::new_with_key([0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1]);
let mut des2 = DES::new_with_key([0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x81ECC05B173F793E_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x4D0AD4DC147E4BDF_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1]
// and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]!!!

§Example 10 for Semi-Weak key case for [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE] and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key([0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE]);
let mut des2 = DES::new_with_key([0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x59735490F84A0AD0_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x79FD3CBFE57F4B0B_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE]
// and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]!!!

§Example 11 for Semi-Weak key case for [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE] and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]

use cryptocol::symmetric::DES;

// Semi-Weak key case 6 for
let mut des1 = DES::new_with_key([0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE]);
let mut des2 = DES::new_with_key([0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x27C83AAE29571889_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xDE76DF630C033919_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE]
// and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]!!!

§Compile-fail Example

use cryptocol::symmetric::DES;
let des = DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
// It cannot be compiled!
des.encrypt_u64(0x1E32B46B44C69201_u64);

Source

pub fn new_with_key_u64(_key: u64) -> Self

Constructs a new object DES_Generic.

§Arguments

The argument key is of u64.
It should be in the same endianness of machine. For example, if a key is [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF], the key in u64 is 0x_1234567890ABCDEF_u64 for big-endian machine, and the key in u64 is 0x_EFCDAB9078563412_u64 for little-endian machine.
Remember that inverted parity bits do not affect the 56-bit real key. So, 0x_0000_0000_0000_0000_u4, 0x_0101_0101_0101_0101_u64, 0x_0000_0000_0000_0001_u64, 0x_0000_0000_0000_0100_u64, 0x_0100_0010_0000_0001_u64, etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

This method sets the key to be the given argument key.

§Example 1 for normal case

use cryptocol::symmetric::DES;

let mut des = DES::new_with_key_u64(0xEFCDAB9078563412);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x3B6041D76AF28F23_u64);

let cipher_cipher_text = des.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x7C5AAE491DC1310D_u64);
assert_ne!(cipher_cipher_text, plaintext);

§Example 2 for Weak key case for 0x0000000000000000

use cryptocol::symmetric::DES;

// The key 0x0000000000000000 is the same key as the key 0x0101010101010101 because of parity bits.
let mut des1 = DES::new_with_key_u64(0x0000000000000000);
let mut des2 = DES::new_with_key_u64(0x0101010101010101);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext2, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0x0000000000000000 and 0x0101010101010101!!!

§Example 3 for Weak key case for 0xFFFFFFFFFFFFFFFF

use cryptocol::symmetric::DES;

// The key 0xFFFFFFFFFFFFFFFF is the same key as the key 0xFEFEFEFEFEFEFEFE because of parity bits.
let mut des1 = DES::new_with_key_u64(0xFFFFFFFFFFFFFFFF);
let mut des2 = DES::new_with_key_u64(0xFEFEFEFEFEFEFEFE);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext2, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0xFFFFFFFFFFFFFFFF and 0xFEFEFEFEFEFEFEFE!!!

§Example 4 for Weak key case for 0xF1F1F1F1E0E0E0E0 in little-endianness

use cryptocol::symmetric::DES;

// The key 0xF1F1F1F1E0E0E0E0 is the same key as the key 0xF0F0F0F0E1E1E1E1 because of parity bits.
let mut des1 = DES::new_with_key_u64(0xF1F1F1F1E0E0E0E0);
let mut des2 = DES::new_with_key_u64(0xF0F0F0F0E1E1E1E1);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext2, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0xF1F1F1F1E0E0E0E0 and 0xF0F0F0F0E1E1E1E1!!!

§Example 5 for Weak key case for 0x0E0E0E0E1F1F1F1F in little-endianness

use cryptocol::symmetric::DES;

// The key 0x0E0E0E0E1F1F1F1F is the same key as the key 0x0F0F0F0F1E1E1E1E because of parity bits.
let mut des1 = DES::new_with_key_u64(0x0E0E0E0E1F1F1F1F);
let mut des2 = DES::new_with_key_u64(0x0F0F0F0F1E1E1E1E);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext2, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0x0E0E0E0E1F1F1F1F and 0x0F0F0F0F1E1E1E1E!!!

§Example 6 for Weak key case for 0x0E010E011F011F01 and 0x010E010E011F011F in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0x0E010E011F011F01);
let mut des2 = DES::new_with_key_u64(0x010E010E011F011F);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xC2C71D736E97876C_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x063A6E55466423D2_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0x0E010E011F011F01 and 0x010E010E011F011F!!!

§Example 7 for Weak key case for 0xF101F101E001E001 and 0x01F101F101E001E0 in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0xF101F101E001E001);
let mut des2 = DES::new_with_key_u64(0x01F101F101E001E0);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x85A63690E79AAA15_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x15B721BBB44A12F5_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xF101F101E001E001 and 0x01F101F101E001E0!!!

§Example 8 for Weak key case for 0xFE01FE01FE01FE01 and 0x01FE01FE01FE01FE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0xFE01FE01FE01FE01);
let mut des2 = DES::new_with_key_u64(0x01FE01FE01FE01FE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xAE38CC9D9FA48581_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x7EE95658A653960D_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFE01FE01FE01FE01 and 0x01FE01FE01FE01FE!!!

§Example 9 for Weak key case for 0xF10EF10EE01FE01F and 0x0EF10EF11FE01FE0 in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0xF10EF10EE01FE01F);
let mut des2 = DES::new_with_key_u64(0x0EF10EF11FE01FE0);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x81ECC05B173F793E_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x4D0AD4DC147E4BDF_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xF10EF10EE01FE01F and 0x0EF10EF11FE01FE0!!!

§Example 10 for Weak key case for 0xFE0EFE0EFE1FFE1F and 0x0EFE0EFE1FFE1FFE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0xFE0EFE0EFE1FFE1F);
let mut des2 = DES::new_with_key_u64(0x0EFE0EFE1FFE1FFE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x59735490F84A0AD0_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x79FD3CBFE57F4B0B_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFE0EFE0EFE1FFE1F and 0x0EFE0EFE1FFE1FFE!!!

§Example 11 for Weak key case for 0xFEF1FEF1FEE0FEE0 and 0xF1FEF1FEE0FEE0FE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new_with_key_u64(0xFEF1FEF1FEE0FEE0);
let mut des2 = DES::new_with_key_u64(0xF1FEF1FEE0FEE0FE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x27C83AAE29571889_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xDE76DF630C033919_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFEF1FEF1FEE0FEE0 and 0xF1FEF1FEE0FEE0FE!!!

Source

pub fn encryptor_with_key(_key: [u8; 8]) -> Self

Constructs a new object DES_Generic as a positive encryptor (or an encryptor) for the component of BigCryptor64 incluing NDES.

§Arguments

The argument key is the array of u8 that has 8 elements.
Remember that inverted parity bits do not affect the 56-bit real key. So, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00], [0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01], etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

You won’t use this method unless you use NDES for such as Triple DES.
This method sets the key to be the given argument key.
This method constructs the encryptor component of NDES.

§Example 1

use cryptocol::symmetric::{ DES, BigCryptor64, SmallCryptor };
 
let keys: [Box<dyn SmallCryptor<u64, 8>>; 3]
        = [ Box::new(DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])),
            Box::new(DES::decryptor_with_key([0x21_u8, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE])),
            Box::new(DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])) ];
let mut tdes = BigCryptor64::new_with_small_cryptor_array(keys);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ DES, BigCryptor64, SmallCryptor };

let mut tdes = DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])
                - DES::encryptor_with_key([0x21_u8, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE])
                + DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn encryptor_with_key_u64(key: u64) -> Self

Constructs a new object DES_Generic as a positive encryptor (or an encryptor) for the component of BigCryptor64 incluing NDES.

§Arguments

The argument key is an unsigned integer that is of u64-type.
Remember that inverted parity bits do not affect the 56-bit real key. So, 0x0000000000000000_u64, 0x0101010101010101_u64, 0x0000000000000001_u64, 0x0000000000000100_u64, 0x0100001000000001, etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

You won’t use this method unless you use NDES for such as Triple DES.
This method sets the key to be the given argument key.
This method constructs the encryptor component of NDES.

§Example 1

use cryptocol::symmetric::{ BigCryptor64, DES };
 
let mut tdes = BigCryptor64::new_with_small_cryptor_array(
            [Box::new(DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64)),
            Box::new(DES::decryptor_with_key_u64(0x_FEDCBA0987654321_u64)),
            Box::new(DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64))]
);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES };

let mut tdes = DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64)
                - DES::encryptor_with_key_u64(0x_FEDCBA0987654321_u64)
                + DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn decryptor_with_key(key: [u8; 8]) -> Self

Constructs a new object DES_Generic as a negative encryptor (or a decryptor) for the component of BigCryptor64 incluing NDES.

§Arguments

The argument key is the array of u8 that has 8 elements.
Remember that inverted parity bits do not affect the 56-bit real key. So, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00], [0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01], etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

You won’t use this method unless you use NDES for such as Triple DES.
This method sets the key to be the given argument key.
This method constructs the encryptor component of NDES.

§Example 1

use cryptocol::symmetric::{ DES, BigCryptor64, SmallCryptor };
 
let keys: [Box<dyn SmallCryptor<u64, 8>>; 3]
        = [ Box::new(DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])),
            Box::new(DES::decryptor_with_key([0x21_u8, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE])),
            Box::new(DES::encryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])) ];
let mut tdes = BigCryptor64::new_with_small_cryptor_array(keys);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ DES, BigCryptor64, SmallCryptor };

let mut tdes = BigCryptor64::new()
                - DES::decryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12])
                - DES::encryptor_with_key([0x21_u8, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE])
                - DES::decryptor_with_key([0xEF_u8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn decryptor_with_key_u64(key: u64) -> Self

Constructs a new object DES_Generic as a negative encryptor (or a decryptor) for the component of BigCryptor64 incluing NDES.

§Arguments

The argument key is an unsigned integer that is of u64-type.
Remember that inverted parity bits do not affect the 56-bit real key. So, 0x0000000000000000_u64, 0x0101010101010101_u64, 0x0000000000000001_u64, 0x0000000000000100_u64, 0x0100001000000001, etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

You won’t use this method unless you use NDES for such as Triple DES.
This method sets the key to be the given argument key.
This method constructs the decryptor component of NDES.

§Example 1

use cryptocol::symmetric::{ BigCryptor64, DES };
 
let mut tdes = BigCryptor64::new_with_small_cryptor_array(
                [ Box::new(DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64)),
                                Box::new(DES::decryptor_with_key_u64(0x_FEDCBA0987654321_u64)),
                                Box::new(DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64)) ] );
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES };

let mut tdes = BigCryptor64::new()
                - DES::decryptor_with_key_u64(0x_1234567890ABCDEF_u64)
                + DES::decryptor_with_key_u64(0x_FEDCBA0987654321_u64)
                - DES::decryptor_with_key_u64(0x_1234567890ABCDEF_u64);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn get_key(&mut self) -> [u8; 8]

Gets the key.

§Output

This method returns the key in the form of array of u8.

§Example

use cryptocol::symmetric::DES;

let mut des = DES::new();
des.set_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
let key = des.get_key();
print!("K = ");
for k in key
    { print!("{:X02#} ", k); }
assert_eq!(key, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);

Source

pub fn get_key_u64(&self) -> u64

Gets the key.

§Output

This method returns the key in the form of u64.

§Example

use cryptocol::symmetric::DES;

let mut des = DES::new();
des.set_key_u64(0xEFCDAB9078563412);
let key = des.get_key_u64();
println!("Key = {}", key);
assert_eq!(key, 0xEFCDAB9078563412_u64);

Source

pub fn set_key(&mut self, key: [u8; 8])

Sets the key.

§Arguments

The argument key is the array of u8 that has 8 elements.
Remember that inverted parity bits do not affect the 56-bit real key. So, [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00], [0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01], etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

This method sets the key to be the given argument key.

§Example 1 for normal case

use cryptocol::symmetric::DES;

let mut des = DES::new();
des.set_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x3B6041D76AF28F23_u64);

let cipher_cipher_text = des.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x7C5AAE491DC1310D_u64);
assert_ne!(cipher_cipher_text, plaintext);

§Example 2 for Weak key case for [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]

use cryptocol::symmetric::DES;

// The key [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] is the same key as the key
// [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01] because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
des2.set_key([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext2, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
// and [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]!!!

§Example 3 for Weak key case for [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

use cryptocol::symmetric::DES;

// The key [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] is the same key as the key
// [0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE] because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
des2.set_key([0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext2, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
// and [0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE]!!!

§Example 4 for Weak key case for [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]

use cryptocol::symmetric::DES;

// The key [0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0] is the same key as the key
// [0xE1, 0xE1, 0xE1, 0xE1, 0xF0, 0xF0, 0xF0, 0xF0] because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]);
des2.set_key([0xE1, 0xE1, 0xE1, 0xE1, 0xF0, 0xF0, 0xF0, 0xF0]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext2, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]
// and [0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1]!!!

§Example 5 for Weak key case for [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]

use cryptocol::symmetric::DES;

// The key [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E] is the same key as the key
// [0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F] because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]);
des2.set_key([0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F]);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext2, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]
// and [0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F]!!!

§Example 5 for Semi-Weak key case for [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E] and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E]);
des2.set_key([0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xC2C71D736E97876C_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x063A6E55466423D2_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E]
// and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]!!!

§Example 6 for Semi-Weak key case for [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1] and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1]);
des2.set_key([0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x85A63690E79AAA15_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x15B721BBB44A12F5_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1]
// and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]!!!

§Example 7 for Semi-Weak key case for [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE] and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE]);
des2.set_key([0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xAE38CC9D9FA48581_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x7EE95658A653960D_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE]
// and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]!!!

§Example 8 for Semi-Weak key case for [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1] and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1]);
des2.set_key([0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x81ECC05B173F793E_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x4D0AD4DC147E4BDF_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1]
// and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]!!!

§Example 9 for Semi-Weak key case for [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE] and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE]);
des2.set_key([0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x59735490F84A0AD0_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x79FD3CBFE57F4B0B_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE]
// and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]!!!

§Example 10 for Semi-Weak key case for [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE] and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key([0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE]);
des2.set_key([0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x27C83AAE29571889_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xDE76DF630C033919_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE]
// and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]!!!

Source

pub fn set_key_u64(&mut self, key: u64)

Sets the key.

§Arguments

The argument key is of u64.
It should be in the same endianness of machine. For example, if a key is [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF], the key in u64 is 0x_1234567890ABCDEF_u64 for big-endian machine, and the key in u64 is 0x_EFCDAB9078563412_u64 for little-endian machine.
Remember that inverted parity bits do not affect the 56-bit real key. So, 0x_0000_0000_0000_0000_u4, 0x_0101_0101_0101_0101_u64, 0x_0000_0000_0000_0001_u64, 0x_0000_0000_0000_0100_u64, 0x_0100_0010_0000_0001_u64, etc. are all the same keys. Each key has 255 different equivalent keys in DES.

§Features

This method sets the key to be the given argument key.

§Example 1 for normal case

use cryptocol::symmetric::DES;

let mut des = DES::new();
des.set_key_u64(0xEFCDAB9078563412);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x3B6041D76AF28F23_u64);

let cipher_cipher_text = des.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x7C5AAE491DC1310D_u64);
assert_ne!(cipher_cipher_text, plaintext);

§Example 2 for Weak key case for 0x0000000000000000

use cryptocol::symmetric::DES;

// The key 0x0000000000000000 is the same key as the key 0x0101010101010101 because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0x0000000000000000);
des2.set_key_u64(0x0101010101010101);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext2, 0x1E32B46B44C69201_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0x0000000000000000 and 0x0101010101010101!!!

§Example 3 for Weak key case for 0xFFFFFFFFFFFFFFFF

use cryptocol::symmetric::DES;

// The key 0xFFFFFFFFFFFFFFFF is the same key as the key 0xFEFEFEFEFEFEFEFE because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xFFFFFFFFFFFFFFFF);
des2.set_key_u64(0xFEFEFEFEFEFEFEFE);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext2, 0xA5997AB38BC07250_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0xFFFFFFFFFFFFFFFF and 0xFEFEFEFEFEFEFEFE!!!

§Example 4 for Weak key case for 0xF1F1F1F1E0E0E0E0 in little-endianness

use cryptocol::symmetric::DES;

// The key 0xF1F1F1F1E0E0E0E0 is the same key as the key 0xF0F0F0F0E1E1E1E1 because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xF1F1F1F1E0E0E0E0);
des2.set_key_u64(0xF0F0F0F0E1E1E1E1);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext2, 0x94CCA0201F033101_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0xF1F1F1F1E0E0E0E0 and 0xF0F0F0F0E1E1E1E1!!!

§Example 5 for Weak key case for 0x0E0E0E0E1F1F1F1F in little-endianness

use cryptocol::symmetric::DES;

// The key 0x0E0E0E0E1F1F1F1F is the same key as the key 0x0F0F0F0F1E1E1E1E because of parity bits.
let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0x0E0E0E0E1F1F1F1F);
des2.set_key_u64(0x0F0F0F0F1E1E1E1E);
let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext1 = des1.encrypt_u64(plaintext);
let ciphertext2 = des2.encrypt_u64(plaintext);

println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext1:\t\t{:#018X}", ciphertext1);
println!("Ciphertext2:\t\t{:#018X}", ciphertext2);
assert_eq!(ciphertext1, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext2, 0x4FB6397B5352DB0C_u64);
assert_eq!(ciphertext1, ciphertext2);

let cipher_cipher_text1 = des1.encrypt_u64(ciphertext1);
let cipher_cipher_text2 = des2.encrypt_u64(ciphertext2);
println!("Cipher-ciphertext1:\t{:#018X}\n", cipher_cipher_text1);
println!("Cipher-ciphertext2:\t{:#018X}\n", cipher_cipher_text2);
assert_eq!(cipher_cipher_text1, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text2, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text1, plaintext);
assert_eq!(cipher_cipher_text2, plaintext);
// So, you can't use the weak key 0x0E0E0E0E1F1F1F1F and 0x0F0F0F0F1E1E1E1E!!!

§Example 6 for Semi-Weak key case for 0x0E010E011F011F01 and 0x010E010E011F011F in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0x0E010E011F011F01);
des2.set_key_u64(0x010E010E011F011F);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xC2C71D736E97876C_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x063A6E55466423D2_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0x0E010E011F011F01 and 0x010E010E011F011F!!!

§Example 7 for Semi-Weak key case for 0x0E010E011F011F01 and 0x010E010E011F011F in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xF101F101E001E001);
des2.set_key_u64(0x01F101F101E001E0);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x85A63690E79AAA15_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x15B721BBB44A12F5_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xF101F101E001E001 and 0x01F101F101E001E0!!!

§Example 8 for Semi-Weak key case for 0xFE01FE01FE01FE01 and 0x01FE01FE01FE01FE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xFE01FE01FE01FE01);
des2.set_key_u64(0x01FE01FE01FE01FE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xAE38CC9D9FA48581_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x7EE95658A653960D_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFE01FE01FE01FE01 and 0x01FE01FE01FE01FE!!!

§Example 9 for Semi-Weak key case for 0xF10EF10EE01FE01F and 0x0EF10EF11FE01FE0 in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xF10EF10EE01FE01F);
des2.set_key_u64(0x0EF10EF11FE01FE0);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x81ECC05B173F793E_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x4D0AD4DC147E4BDF_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xF10EF10EE01FE01F and 0x0EF10EF11FE01FE0!!!

§Example 10 for Semi-Weak key case for 0xFE0EFE0EFE1FFE1F and 0x0EFE0EFE1FFE1FFE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xFE0EFE0EFE1FFE1F);
des2.set_key_u64(0x0EFE0EFE1FFE1FFE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x59735490F84A0AD0_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x79FD3CBFE57F4B0B_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFE0EFE0EFE1FFE1F and 0x0EFE0EFE1FFE1FFE!!!

§Example 11 for Semi-Weak key case for 0xFEF1FEF1FEE0FEE0 and 0xF1FEF1FEE0FEE0FE in little-endianness

use cryptocol::symmetric::DES;

let mut des1 = DES::new();
let mut des2 = DES::new();
des1.set_key_u64(0xFEF1FEF1FEE0FEE0);
des2.set_key_u64(0xF1FEF1FEE0FEE0FE);

let plaintext = 0x1234567890ABCDEF_u64;
let ciphertext = des1.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x27C83AAE29571889_u64);

let cipher_cipher_text = des2.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

let ciphertext = des2.encrypt_u64(plaintext);
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0xDE76DF630C033919_u64);

let cipher_cipher_text = des1.encrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}\n", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);
// So, you can't use the semi-weak keys 0xFEF1FEF1FEE0FEE0 and 0xF1FEF1FEE0FEE0FE!!!

Source

pub fn turn_inverse(&mut self)

Flips its role in BigCryptor64.

§Features

You won’t use this method unless you use BigCryptor64 or NDES for such as Triple DES.
Even if you are writing codes in the context of using BigCryptor64 or NDES, you will hardly use this method because it is high chance that you will have constructed components with the methods, encryptor_with_key, encryptor_with_key_u64, decryptor_with_key, and decryptor_with_key_u64.
If it is constructed as encryptor for BigCryptor64 or NDES, it will be changed into decryptor.
If it is constructed as decryptor for BigCryptor64 or NDES, it will be changed into encryptor.

§Example 1

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let mut keys: [Box<dyn SmallCryptor<u64, 8>>; 3]
            = [ Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)),
                Box::new(DES::new_with_key_u64(0x_FEDCBA0987654321_u64)),
                Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)) ];
keys[1].turn_inverse();
 
let mut tdes = BigCryptor64::new_with_small_cryptor_array(keys);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let des1 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
let mut des2 = DES::new_with_key_u64(0x_FEDCBA0987654321_u64);
let des3 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
des2.turn_inverse();
 
let mut tdes = BigCryptor64::new() + des1 + des2 + des3; 
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn turn_encryptor(&mut self)

Changes its role in BigCryptor64 or NDES to encryptor.

§Features

You won’t use this method unless you use BigCryptor64 or NDES for such as Triple DES.
Even if you are writing codes in the context of using BigCryptor64 or NDES, you will hardly use this method because it is high chance that you will have constructed components with the methods, encryptor_with_key, encryptor_with_key_u64, decryptor_with_key, and decryptor_with_key_u64.
If it is constructed as encryptor for BigCryptor64 or NDES, it will not be changed at all.
If it is constructed as decryptor for BigCryptor64 or NDES, it will be changed into encryptor.

§Example 1

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let mut keys: [Box<dyn SmallCryptor<u64, 8>>; 3]
        = [ Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)),
            Box::new(DES::new_with_key_u64(0x_FEDCBA0987654321_u64)),
            Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)) ];
keys[0].turn_encryptor();
 
let mut tdes = BigCryptor64::new_with_small_cryptor_array(keys);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_CDAC175F3B7EAA2B_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let mut des1 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
let des2 = DES::new_with_key_u64(0x_FEDCBA0987654321_u64);
let des3 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
des1.turn_encryptor();
 
let mut tdes = BigCryptor64::new() + des1 + des2 + des3; 
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_CDAC175F3B7EAA2B_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn turn_decryptor(&mut self)

Changes its role in BigCryptor64 or NDES to decryptor.

§Features

You won’t use this method unless you use BigCryptor64 or NDES for such as Triple DES.
Even if you are writing codes in the context of using BigCryptor64 or NDES, you will hardly use this method because it is high chance that you will have constructed components with the methods, encryptor_with_key, encryptor_with_key_u64, decryptor_with_key, and decryptor_with_key_u64.
If it is constructed as encryptor for BigCryptor64 or NDES, it will be changed into decryptor.
If it is constructed as decryptor for BigCryptor64 or NDES, it will not be changed at all.

§Example 1

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let mut keys: [Box<dyn SmallCryptor<u64, 8>>; 3]
            = [ Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)),
                Box::new(DES::new_with_key_u64(0x_FEDCBA0987654321_u64)),
                Box::new(DES::new_with_key_u64(0x_1234567890ABCDEF_u64)) ];
keys[1].turn_decryptor();
 
let mut tdes = BigCryptor64::new_with_small_cryptor_array(keys);
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES, SmallCryptor };
 
let des1 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
let mut des2 = DES::new_with_key_u64(0x_FEDCBA0987654321_u64);
let des3 = DES::new_with_key_u64(0x_1234567890ABCDEF_u64);
des2.turn_decryptor();
 
let mut tdes = BigCryptor64::new() + des1 + des2 + des3; 
let plaintext = 0x_1234567890ABCDEF_u64;
let ciphertext = tdes.encrypt_u64(plaintext);
 
println!("Plaintext:\t\t{:#018X}", plaintext);
println!("Ciphertext:\t\t{:#018X}", ciphertext);
assert_eq!(ciphertext, 0x_272A2AC7B4E66748_u64);
 
let cipher_cipher_text = tdes.decrypt_u64(ciphertext);
println!("Cipher-ciphertext:\t{:#018X}", cipher_cipher_text);
assert_eq!(cipher_cipher_text, 0x_1234567890ABCDEF_u64);
assert_eq!(cipher_cipher_text, plaintext);

Source

pub fn encrypt_u64(&mut self, message: u64) -> u64

Encrypts a 64-bit data.

§Arguments

message is of u64-type and the plaintext to be encrypted.

§Output

This method returns the encrypted data of u64-type from message.

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut a_des = DES::new_with_key_u64(key);
let cipher = a_des.encrypt_u64(message);
println!("C_u64 (16 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_1BC4896735BBE206_u64);

§Example 2 for 128 rounds

use cryptocol::symmetric::DES_Expanded;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);
let cipher = b_des.encrypt_u64(message);
println!("C_u64 (128 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_21F25F81CE4D4AA3_u64);

§Example 3 for 0 rounds which means that key is meaningless

use cryptocol::symmetric::DES_Expanded;

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K1 =\t{:#016x}", key1);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let cipher1 = c_des.encrypt_u64(message);
let cipher2 = d_des.encrypt_u64(message);
println!("C_u64 (0 rounds) =\t{:#018X}", cipher1);
assert_eq!(cipher1, 0x_2138A9B46057CEDF_u64);

println!("D_u64 (0 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher2, 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1, cipher2);

Source

pub fn decrypt_u64(&mut self, cipher: u64) -> u64

Decrypts a 64-bit data.

§Arguments

cioher is of u64-type and the ciphertext to be decrypted.

§Output

This method returns the decrypted data of u64-type from cipher.

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut a_des = DES::new_with_key_u64(key);
let cipher = a_des.encrypt_u64(message);
println!("C_u64 (16 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_1BC4896735BBE206_u64);

let recovered = a_des.decrypt_u64(cipher);
println!("B_u64 (16 rounds) =\t{:#018X}", recovered);
assert_eq!(recovered, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered, message);

§Example 2 for for 128 rounds

use cryptocol::symmetric::DES_Expanded;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);
let cipher = b_des.encrypt_u64(message);
println!("C_u64 (128 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_21F25F81CE4D4AA3_u64);

let recovered = b_des.decrypt_u64(cipher);
println!("B_u64 (16 rounds) =\t{:#018X}", recovered);
assert_eq!(recovered, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered, message);

§Example 3 for for 0 rounds which means that key is meaningless

use cryptocol::symmetric::{ DES, DES_Expanded };

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let cipher1 = c_des.encrypt_u64(message);
let cipher2 = d_des.encrypt_u64(message);
println!("C_u64 (0 rounds) =\t{:#018X}", cipher1);
assert_eq!(cipher1, 0x_2138A9B46057CEDF_u64);

println!("D_u64 (0 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher2, 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1, cipher2);

let recovered1 = c_des.decrypt_u64(cipher1);
let recovered2 = d_des.decrypt_u64(cipher2);
println!("B1_u64 (0 rounds) =\t{:#018X}", recovered1);
println!("B2_u64 (0 rounds) =\t{:#018X}", recovered2);
assert_eq!(recovered1, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered1, message);
assert_eq!(recovered2, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered2, message);
assert_eq!(recovered1, recovered2);

Source

pub fn _encrypt(&mut self, message: u64) -> u64

Encrypts a 64-bit data when NDES encrypting if the object was constructed as encryptor for NDES such as Triple DES, and decrypts a 64-bit data when NDES encrypting if the object was constructed as decryptor for NDES such as Triple DES.

§Arguments

message is of u64-type and the plaintext to be encrypted.

§Output

This method returns the encrypted data of u64-type from message.

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut a_des = DES::new_with_key_u64(key);
let cipher = a_des._encrypt(message);
println!("C_u64 (16 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_1BC4896735BBE206_u64);

§Example 2 for Expanded case for 128 rounds

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);
let cipher = b_des._encrypt(message);
println!("C_u64 (128 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_21F25F81CE4D4AA3_u64);

§Example 3 for Expanded case for 0 rounds which means that key is meaningless

use cryptocol::symmetric::DES;

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K1 =\t{:#016x}", key1);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let cipher1 = c_des._encrypt(message);
let cipher2 = d_des._encrypt(message);
println!("C_u64 (0 rounds) =\t{:#018X}", cipher1);
assert_eq!(cipher1, 0x_2138A9B46057CEDF_u64);

println!("D_u64 (0 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher2, 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1, cipher2);

Source

pub fn _decrypt(&mut self, cipher: u64) -> u64

Decrypts a 64-bit data when NDES decrypting if the object was constructed as encryptor for NDES such as Triple DES, and encrypts a 64-bit data when NDES decrypting if the object was constructed as decryptor for NDES such as Triple DES.

§Arguments

cipher is of u64-type and the ciphertext to be decrypted.

§Output

This method returns the decrypted data of u64-type from cipher.

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut a_des = DES::new_with_key_u64(key);
let cipher = a_des._encrypt(message);
println!("C_u64 (16 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_1BC4896735BBE206_u64);

let recovered = a_des._decrypt(cipher);
println!("B_u64 (16 rounds) =\t{:#018X}", recovered);
assert_eq!(recovered, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered, message);

§Example 2 for Expanded case for 128 rounds

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);
let cipher = b_des._encrypt(message);
println!("C_u64 (128 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher, 0x_21F25F81CE4D4AA3_u64);

let recovered = b_des._decrypt(cipher);
println!("B_u64 (16 rounds) =\t{:#018X}", recovered);
assert_eq!(recovered, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered, message);

§Example 3 for Expanded case for 0 rounds which means that key is meaningless

use cryptocol::symmetric::DES;

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K =\t{:#018X}", key);

let message = 0x_1234567890ABCDEF_u64;
println!("M_u64 =\t{:#018X}", message);

let cipher1 = c_des._encrypt(message);
let cipher2 = d_des._encrypt(message);
println!("C_u64 (0 rounds) =\t{:#018X}", cipher1);
assert_eq!(cipher1, 0x_2138A9B46057CEDF_u64);

println!("D_u64 (0 rounds) =\t{:#018X}", cipher);
assert_eq!(cipher2, 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1, cipher2);

let recovered1 = c_des._decrypt(cipher1);
let recovered2 = d_des._decrypt(cipher2);
println!("B1_u64 (0 rounds) =\t{:#018X}", recovered1);
println!("B2_u64 (0 rounds) =\t{:#018X}", recovered2);
assert_eq!(recovered1, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered1, message);
assert_eq!(recovered2, 0x_1234567890ABCDEF_u64);
assert_eq!(recovered2, message);
assert_eq!(recovered1, recovered2);

Source

pub fn encrypt_array_u64<const N: usize>( &mut self, message: &[u64; N], cipher: &mut [u64; N], )

Encrypts an array of 64-bit data.

§Arguments

message is of an array of u64-type and the plaintext to be encrypted.
cipher is of an array of u64-type and the ciphertext to be stored.

§Features

This method encrypts multiple of 64-bit data without padding anything in ECB (Electronic Code Book) mode.

§Counterpart methods

If you need to encrypt data with padding bits according PKCS #7 in ECB operation mode, you may need to import (use) cryptocol::symmetric::ECB_PKCS7. see here
If you need to encrypt data with padding bits according ISO in ECB operation mode, you may need to import (use) cryptocol::symmetric::ECB_ISO. see here
If you need to encrypt data with padding bits according PKCS #7 in CBC operation mode, you may need to import (use) cryptocol::symmetric::CBC_PKCS7. see here
If you need to encrypt data with padding bits according ISO in CBC operation mode, you may need to import (use) cryptocol::symmetric::CBC_ISO. see here
If you need to encrypt data with padding bits according PKCS #7 in PCBC operation mode, you may need to import (use) cryptocol::symmetric::PCBC_PKCS7. see here
If you need to encrypt data with padding bits according ISO in PCBC operation mode, you may need to import (use) cryptocol::symmetric::PCBC_ISO. see here
If you need to encrypt data in CFB operation mode, you may need to import (use) cryptocol::symmetric::CFB. see here
If you need to encrypt data in OFB operation mode, you may need to import (use) cryptocol::symmetric::OFB. see here
If you need to encrypt data in CTR operation mode, you may need to import (use) cryptocol::symmetric::CTR. see here

In summary,

	padding PKCS7	padding ISO	no padding
ECB	ECB_PKCS7	ECB_ISO
CBC	CBC_PKCS7	CBC_ISO
PCBC	PCBC_PKCS7	PCBC_ISO
CFB			CFB
OFB			OFB
CTR			CTR

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();
let mut a_des = DES::new_with_key_u64(key);

let mut cipher = [0; 3];
a_des.encrypt_array_u64(&message, &mut cipher);
print!("C (16 rounds) =\t");
for c in cipher
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher[0], 0x_1BC4896735BBE206_u64);
assert_eq!(cipher[1], 0x_1D8A61E5E62226A4_u64);
assert_eq!(cipher[2], 0x_2990D69525C17067_u64);

§Example 2 for 128 rounds

use cryptocol::symmetric::DES_Expanded;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();
let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);

let mut cipher = [0; 3];
b_des.encrypt_array_u64(&message, &mut cipher);
print!("C (128 rounds) =\t");
for c in cipher
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher[0], 0x_21F25F81CE4D4AA3_u64);
assert_eq!(cipher[1], 0x_352F391A1482A504_u64);
assert_eq!(cipher[2], 0x_F793546957AFDE50_u64);

§Example 3 for 0 rounds which means that key is meaningless

use cryptocol::symmetric::DES_Expanded;

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();

let mut cipher1 = [0; 3];
let mut cipher2 = [0; 3];
c_des.encrypt_array_u64(&message, &mut cipher1);
d_des.encrypt_array_u64(&message, &mut cipher2);
print!("C (0 rounds) =\t");
for c in cipher1
    { print!("{:#018X} ", c); }
println!();
print!("D (0 rounds) =\t");
for c in cipher2
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher1[0], 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1[1], 0x_DFCE5760B4A93821_u64);
assert_eq!(cipher1[2], 0x_FDEC75064B9A8312_u64);
assert_eq!(cipher2[0], 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher2[1], 0x_DFCE5760B4A93821_u64);
assert_eq!(cipher2[2], 0x_FDEC75064B9A8312_u64);
assert_eq!(cipher1[0], cipher2[0]);
assert_eq!(cipher1[1], cipher2[1]);
assert_eq!(cipher1[2], cipher2[2]);

Source

pub fn decrypt_array_u64<const N: usize>( &mut self, cipher: &[u64; N], message: &mut [u64; N], )

Decrypts an array of 64-bit data.

§Arguments

cipher is of an array of u64-type and the ciphertext to be decrypted.
message is of an array of u64-type and the plaintext to be stored.

§Features

This method decrypts multiple of 64-bit data without padding anything in ECB (Electronic Code Book) mode.

§Counterpart methods

If you need to decrypt data with padding bits according PKCS #7 in ECB operation mode, you may need to import (use) cryptocol::symmetric::ECB_PKCS7. see here
If you need to decrypt data with padding bits according ISO in ECB operation mode, you may need to import (use) cryptocol::symmetric::ECB_ISO. see here
If you need to decrypt data with padding bits according PKCS #7 in CBC operation mode, you may need to import (use) cryptocol::symmetric::CBC_PKCS7. see here
If you need to decrypt data with padding bits according ISO in CBC operation mode, you may need to import (use) cryptocol::symmetric::CBC_ISO. see here
If you need to decrypt data with padding bits according PKCS #7 in PCBC operation mode, you may need to import (use) cryptocol::symmetric::PCBC_PKCS7. see here
If you need to decrypt data with padding bits according ISO in PCBC operation mode, you may need to import (use) cryptocol::symmetric::PCBC_ISO. see here
If you need to decrypt data in CFB operation mode, you may need to import (use) cryptocol::symmetric::CFB. see here
If you need to decrypt data in OFB operation mode, you may need to import (use) cryptocol::symmetric::OFB. see here
If you need to decrypt data in CTR operation mode, you may need to import (use) cryptocol::symmetric::CTR. see here

In summary,

	padding PKCS7	padding ISO	no padding
ECB	ECB_PKCS7	ECB_ISO
CBC	CBC_PKCS7	CBC_ISO
PCBC	PCBC_PKCS7	PCBC_ISO
CFB			CFB
OFB			OFB
CTR			CTR

§Example 1 for Normal case

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();
let mut a_des = DES::new_with_key_u64(key);

let mut cipher = [0; 3];
a_des.encrypt_array_u64(&message, &mut cipher);
print!("C (16 rounds) =\t");
for c in cipher
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher[0], 0x_1BC4896735BBE206_u64);
assert_eq!(cipher[1], 0x_1D8A61E5E62226A4_u64);
assert_eq!(cipher[2], 0x_2990D69525C17067_u64);

let mut recovered = [0; 3];
a_des.decrypt_array_u64(&cipher, &mut recovered);
print!("B (16 rounds) =\t");
for r in recovered
    { print!("{:#018X} ", r); }
println!();
assert_eq!(recovered[0], 0x_1234567890ABCDEF_u64);
assert_eq!(recovered[1], 0x_EFCDAB9078563412_u64);
assert_eq!(recovered[2], 0x_FEDCBA0987654321_u64);

§Example 2 for 128 rounds

use cryptocol::symmetric::DES_Expanded;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();
let mut b_des = DES_Expanded::<128, 0x_8103_8103_8103_8103_8103_8103_8103_8103_u128>::new_with_key_u64(key);

let mut cipher = [0; 3];
b_des.encrypt_array_u64(&message, &mut cipher);
print!("C (128 rounds) =\t");
for c in cipher
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher[0], 0x_21F25F81CE4D4AA3_u64);
assert_eq!(cipher[1], 0x_352F391A1482A504_u64);
assert_eq!(cipher[2], 0x_F793546957AFDE50_u64);

let mut recovered = [0; 3];
b_des.decrypt_array_u64(&cipher, &mut recovered);
print!("B (128 rounds) =\t");
for r in recovered
    { print!("{:#018X} ", r); }
println!();
assert_eq!(recovered[0], 0x_1234567890ABCDEF_u64);
assert_eq!(recovered[1], 0x_EFCDAB9078563412_u64);
assert_eq!(recovered[2], 0x_FEDCBA0987654321_u64);

§Example 3 for 0 rounds which means that key is meaningless

use cryptocol::symmetric::DES_Expanded;

let key1 = 0x_1234567890ABCDEF_u64;
let key2 = 0_u64;
let mut c_des = DES_Expanded::<0, 0>::new_with_key_u64(key1);
let mut d_des = DES_Expanded::<0, 0>::new_with_key_u64(key2);
println!("K =\t{:#018X}", key);

let message = [0x_1234567890ABCDEF_u64, 0xEFCDAB9078563412, 0xFEDCBA0987654321 ];
print!("M =\t");
for m in message
    { print!("{:#018X} ", m); }
println!();

let mut cipher1 = [0; 3];
let mut cipher2 = [0; 3];
c_des.encrypt_array_u64(&message, &mut cipher1);
d_des.encrypt_array_u64(&message, &mut cipher2);
print!("C (0 rounds) =\t");
for c in cipher1
    { print!("{:#018X} ", c); }
println!();
print!("D (0 rounds) =\t");
for c in cipher2
    { print!("{:#018X} ", c); }
println!();
assert_eq!(cipher1[0], 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher1[1], 0x_DFCE5760B4A93821_u64);
assert_eq!(cipher1[2], 0x_FDEC75064B9A8312_u64);
assert_eq!(cipher2[0], 0x_2138A9B46057CEDF_u64);
assert_eq!(cipher2[1], 0x_DFCE5760B4A93821_u64);
assert_eq!(cipher2[2], 0x_FDEC75064B9A8312_u64);
assert_eq!(cipher1[0], cipher2[0]);
assert_eq!(cipher1[1], cipher2[1]);
assert_eq!(cipher1[2], cipher2[2]);

let mut recovered1 = [0; 3];
let mut recovered2 = [0; 3];
c_des.decrypt_array_u64(&cipher1, &mut recovered1);
d_des.decrypt_array_u64(&cipher2, &mut recovered2);
print!("B1 (0 rounds) =\t");
for r in recovered1
    { print!("{:#018X} ", r); }
println!();
print!("B2 (0 rounds) =\t");
for r in recovered2
    { print!("{:#018X} ", r); }
println!();
assert_eq!(recovered1[0], 0x_1234567890ABCDEF_u64);
assert_eq!(recovered1[1], 0x_EFCDAB9078563412_u64);
assert_eq!(recovered1[2], 0x_FEDCBA0987654321_u64);
assert_eq!(recovered2[0], 0x_1234567890ABCDEF_u64);
assert_eq!(recovered2[1], 0x_EFCDAB9078563412_u64);
assert_eq!(recovered2[2], 0x_FEDCBA0987654321_u64);
assert_eq!(recovered1[0], recovered2[0]);
assert_eq!(recovered1[1], recovered2[1]);
assert_eq!(recovered1[2], recovered2[2]);

Source

pub fn is_successful(&self) -> bool

Checks whether the previous encryption or decryption was successful.

§Output

If the previous encryption or decryption was successful, this method returns true. Otherwise, it returns false.

§Features

Usually, you don’t have to use this method because the encryption methods returns the length of ciphertext and the decryption methods returns the length of plaintext but they returns 0 when they failed.
If the ciphertext is 8 bytes for decryption with the padding either pkcs7 or iso, the return value 0 of the decryption methods is not discriminatory. You don’t know whether the previous decryption was failed or the original plaintext was just null string or “”. In this case you can check its success with this method.

§Example 1 for Normal case for the message of 0 bytes

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ DES, ECB_PKCS7 };
 
let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);
let message = "";
println!("M =\t{}", message);
let mut cipher = [0_u8; 8];
let len = a_des.encrypt_into_array(message.as_ptr(), message.len() as u64, &mut cipher);
println!("The length of ciphertext = {}", len);
assert_eq!(len, 8);
let success = a_des.is_successful();
assert_eq!(success, true);
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
println!();
let mut txt = String::new();
for c in cipher.clone()
    { write!(txt, "{:02X} ", c); }
assert_eq!(txt, "41 7F 89 79 08 CD A1 4C ");

§Example 2 for Normal case for the original message of 0 bytes

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ DES, ECB_PKCS7 };

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);
 
let cipher = [0x41u8, 0x7F, 0x89, 0x79, 0x08, 0xCD, 0xA1, 0x4C];
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
println!();
let mut recovered = [0u8; 8];
let len = a_des.decrypt_array_into_array(&cipher, &mut recovered);
println!("The length of plaintext = {}", len);
assert_eq!(len, 0);
let success = a_des.is_successful();
assert_eq!(success, true);
print!("Ba =\t");
for b in recovered.clone()
    { print!("{:02X} ", b); }
println!();
let mut txt = String::new();
for c in recovered.clone()
    { write!(txt, "{:02X} ", c); }
assert_eq!(txt, "00 00 00 00 00 00 00 00 ");
 
let mut converted = String::new();
unsafe { converted.as_mut_vec() }.write(&recovered);
unsafe { converted.as_mut_vec() }.truncate(len as usize);
println!("Bb =\t{}", converted);
assert_eq!(converted, "");
assert_eq!(converted, message);

§Example 3 for Failed case for encryption

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ DES, CFB };

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);
 
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let iv = 0x_FEDCBA0987654321_u64;
println!("IV =	{}", iv);
let mut cipher = [0_u8; 40];
let len = a_des.encrypt_into_array(iv, message.as_ptr(), message.len() as u64, &mut cipher);
println!("The length of ciphertext = {}", len);
assert_eq!(len, 0);
let success = a_des.is_successful();
assert_eq!(success, false);

§Example 4 for Failed case for decryption

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ DES, CFB };

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);
 
let cipher = [0x2Eu8, 0x1E, 0xE1, 0x51, 0xFD, 0xB3, 0xB0, 0x4B, 0x79, 0x3A, 0xA1, 0x78, 0xEC, 0xCD, 0x02, 0x72, 0x6A, 0xC4, 0x41, 0x7C, 0x25, 0xA4, 0x2C, 0x07, 0xFC, 0x77, 0x25, 0x49, 0x12, 0x55, 0x0F, 0x8A, 0xED, 0x44, 0xC3, 0xE4, 0xDC, 0x91, 0x69, 0x0F, 0x40, 0x72, 0x7F, 0xF2, 0xD9, 0xB7, 0x54, 0x9F, 0x36, 0x91, 0xC5, 0x85, 0x4F, 0x9B, 0x30];
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
println!();
let mut recovered = [0u8; 40];
let len = a_des.decrypt_array_into_array(iv, &cipher, &mut recovered);
println!("The length of plaintext = {}", len);
assert_eq!(len, 0);
let success = a_des.is_successful();
assert_eq!(success, false);

Source

pub fn is_failed(&self) -> bool

Checks whether the previous encryption or decryption was failed.

§Output

If the previous encryption or decryption was failed, this method returns true. Otherwise, it returns false.

§Features

Usually, you don’t have to use this method because the encryption methods returns the length of ciphertext and the decryption methods returns the length of plaintext but they returns 0 when they failed.
If the ciphertext is 8 bytes for decryption with the padding either pkcs7 or iso, the return value 0 of the decryption methods is not discriminatory. You don’t know whether the previous decryption was failed or the original plaintext was just null string or “”. In this case you can check its success with this method.

§Example 1 for Normal case for the message of 0 bytes

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);

let message = "";
println!("M =\t{}", message);
let mut cipher = [0_u8; 8];
let len = a_des.encrypt_with_padding_pkcs7_into_array(message.as_ptr(), message.len() as u64, &mut cipher);
println!("The length of ciphertext = {}", len);
assert_eq!(len, 8);
let failure = a_des.is_failed();
assert_eq!(failure, false);
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
println!();
let mut txt = String::new();
for c in cipher.clone()
    { write!(txt, "{:02X} ", c); }
assert_eq!(txt, "41 7F 89 79 08 CD A1 4C ");

§Example 2 for Normal case for the original message of 0 bytes

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::DES;

let cipher = [0x41u8, 0x7F, 0x89, 0x79, 0x08, 0xCD, 0xA1, 0x4C];
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
let mut recovered = [0u8; 8];
let len = a_des.decrypt_array_with_padding_pkcs7_into_array(&cipher, &mut recovered);
println!("The length of plaintext = {}", len);
assert_eq!(len, 0);
let failure = a_des.is_failed();
assert_eq!(failure, false);
print!("Ba =\t");
for b in recovered.clone()
    { print!("{:02X} ", b); }
println!();
let mut txt = String::new();
for c in recovered.clone()
    { write!(txt, "{:02X} ", c); }
assert_eq!(txt, "00 00 00 00 00 00 00 00 ");

let mut converted = String::new();
unsafe { converted.as_mut_vec() }.write(&recovered);
unsafe { converted.as_mut_vec() }.truncate(len as usize);
println!("Bb =\t{}", converted);
assert_eq!(converted, "");
assert_eq!(converted, message);

§Example 3 for Failed case for encryption

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);

let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let iv = 0x_FEDCBA0987654321_u64;
println!("IV =	{}", iv);
let mut cipher = [0_u8; 40];
let len = a_des.encrypt_cfb_into_array(iv, message.as_ptr(), message.len() as u64, &mut cipher);
println!("The length of ciphertext = {}", len);
assert_eq!(len, 0);
let failure = a_des.is_failed();
assert_eq!(failure, true);

§Example 4 for Failed case for decryption

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
println!("K =\t{:#018X}", key);
let mut a_des = DES::new_with_key_u64(key);

let cipher = [0x2Eu8, 0x1E, 0xE1, 0x51, 0xFD, 0xB3, 0xB0, 0x4B, 0x79, 0x3A, 0xA1, 0x78, 0xEC, 0xCD, 0x02, 0x72, 0x6A, 0xC4, 0x41, 0x7C, 0x25, 0xA4, 0x2C, 0x07, 0xFC, 0x77, 0x25, 0x49, 0x12, 0x55, 0x0F, 0x8A, 0xED, 0x44, 0xC3, 0xE4, 0xDC, 0x91, 0x69, 0x0F, 0x40, 0x72, 0x7F, 0xF2, 0xD9, 0xB7, 0x54, 0x9F, 0x36, 0x91, 0xC5, 0x85, 0x4F, 0x9B, 0x30];
print!("C =\t");
for c in cipher.clone()
    { print!("{:02X} ", c); }
let mut recovered = [0u8; 40];
let len = a_des.decrypt_array_cfb_into_array(iv, &cipher, &mut recovered);
println!("The length of plaintext = {}", len);
assert_eq!(len, 0);
let failure = a_des.is_failed();
assert_eq!(failure, true);

Source

pub fn has_weak_key(&mut self) -> bool

Checks wether or not it has a weak key.

§Output

This method returns true if it has a weak key. Otherwise, it returns false.

§Example 1 for not weak key

use cryptocol::symmetric::DES;

let key = 0x_1234567890ABCDEF_u64;
let mut a_des = DES::new_with_key_u64(key);
let weak_key = a_des.has_weak_key();
println!("{:016X} is {}a weak key.", key.to_be(), if weak_key {""} else {"not "});
assert_eq!(weak_key, false);

§Example 2 for weak key

use cryptocol::symmetric::DES;

let key = 0x_0000000000000000_u64;
a_des.set_key_u64(key);
let weak_key = a_des.has_weak_key();
println!("{:016X} is {}a weak key.", key.to_be(), if weak_key {""} else {"not "});
assert_eq!(weak_key, true);

Auto Trait Implementations§

§

impl UnwindSafe for DES_Generic

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

DES_Generic

Struct DES_Generic Copy item path

Implementations§

impl DES_Generic

pub fn new() -> Self

§Features

§Example 1

§Compile-fail Example

pub fn new_with_key(_key: [u8; 8]) -> Self

§Arguments

§Features

§Example 1 for normal case

§Example 2 for Weak key case for [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]

§Example 3 for Weak key case for [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

§Example 4 for Weak key case for [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]

§Example 5 for Weak key case for [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]

§Example 6 for Semi-Weak key case for [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E] and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]

§Example 7 for Semi-Weak key case for [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1] and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]

§Example 8 for Semi-Weak key case for [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE] and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]

§Example 9 for Semi-Weak key case for [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1] and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]

§Example 10 for Semi-Weak key case for [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE] and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]

§Example 11 for Semi-Weak key case for [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE] and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]

§Compile-fail Example

pub fn new_with_key_u64(_key: u64) -> Self

§Arguments

§Features

§Example 1 for normal case

§Example 2 for Weak key case for 0x0000000000000000

§Example 3 for Weak key case for 0xFFFFFFFFFFFFFFFF

§Example 4 for Weak key case for 0xF1F1F1F1E0E0E0E0 in little-endianness

§Example 5 for Weak key case for 0x0E0E0E0E1F1F1F1F in little-endianness

§Example 6 for Weak key case for 0x0E010E011F011F01 and 0x010E010E011F011F in little-endianness

§Example 7 for Weak key case for 0xF101F101E001E001 and 0x01F101F101E001E0 in little-endianness

§Example 8 for Weak key case for 0xFE01FE01FE01FE01 and 0x01FE01FE01FE01FE in little-endianness

§Example 9 for Weak key case for 0xF10EF10EE01FE01F and 0x0EF10EF11FE01FE0 in little-endianness

§Example 10 for Weak key case for 0xFE0EFE0EFE1FFE1F and 0x0EFE0EFE1FFE1FFE in little-endianness

§Example 11 for Weak key case for 0xFEF1FEF1FEE0FEE0 and 0xF1FEF1FEE0FEE0FE in little-endianness

pub fn encryptor_with_key(_key: [u8; 8]) -> Self

§Arguments

§Features

§Example 1

§Example 2

pub fn encryptor_with_key_u64(key: u64) -> Self

§Arguments

§Features

§Example 1

§Example 2

pub fn decryptor_with_key(key: [u8; 8]) -> Self

§Arguments

§Features

§Example 1

§Example 2

pub fn decryptor_with_key_u64(key: u64) -> Self

§Arguments

§Features

§Example 1

§Example 2

pub fn get_key(&mut self) -> [u8; 8]

§Output

§Example

pub fn get_key_u64(&self) -> u64

§Output

§Example

pub fn set_key(&mut self, key: [u8; 8])

§Arguments

§Features

§Example 1 for normal case

§Example 2 for Weak key case for [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]

§Example 3 for Weak key case for [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]

§Example 4 for Weak key case for [0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1]

§Example 5 for Weak key case for [0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E]

§Example 5 for Semi-Weak key case for [0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E] and [0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01]

§Example 6 for Semi-Weak key case for [0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1] and [0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01]

§Example 7 for Semi-Weak key case for [0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE] and [0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01]

§Example 8 for Semi-Weak key case for [0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1] and [0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E]

§Example 9 for Semi-Weak key case for [0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE] and [0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E]

§Example 10 for Semi-Weak key case for [0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE] and [0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1]

pub fn set_key_u64(&mut self, key: u64)

§Arguments

§Features

Struct DES_Generic