Struct BigCryptor64

Source

pub struct BigCryptor64 { /* private fields */ }

Expand description

A BigCryptor64 wrapper struct for cascading encryption/decryption algorithms that has 64-bit block size

§Introduction

BigCryptor64 is mainly used to make TDES which folds DES by cascading DES three times. However, it can be used to cascade any encryption/decryption algorithms that has 64-bit block size.

§Quick Start

You have to import (use) the module BigCryptor64 in order to cascade encryption/decryption algorithms that has 64-bit block size such as DES as shown in Example 1.

§Example 1

use cryptocol::symmetric::BigCryptor64;

You can instantiate the BigCryptor64 object with components (hereinafter, referred to as small cryptor) that has u64 keys as Example 2, for example. In this case, you have to take endianness into account. In little-endianness, 0x_1234567890ABCDEF_u64 is [0xEFu8, 0xCDu8, 0xABu8, 0x90u8, 0x78u8, 0x56u8, 0x34u8, 0x12u8] while the same 0x_1234567890ABCDEF_u64 is [0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x90u8, 0xABu8, 0xCDu8, 0xEF_u64] in big-endianness. The instantiated object should be mutable.

§Example 2

use cryptocol::symmetric::{ BigCryptor64, DES };
let mut _tdes = BigCryptor64::new()
                + DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64)
                + DES::decryptor_with_key_u64(0x_FEDCBA0987654321_u64)
                + DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64);

Also, you can instantiate the BigCryptor64 object with small cryptors (component) that have [u8; 8] keys as shown in Example 3. In this case, you don’t have to take endianness into account. The instantiated object should be mutable.

§Example 3

use cryptocol::symmetric::{ BigCryptor64, DES };
let mut _tdes = BigCryptor64::new()
                + DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF])
                - DES::new_with_key([0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21])
                + DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);

You can instantiate the BigCryptor64 object without small cryptors (components) that have key and set a u64 key later as shown in Example 4 or [u8; 8] keys later as shown in Example 5.

§Example 4

use cryptocol::symmetric::{ BigCryptor64, DES };
let mut tdes = BigCryptor64::new();
let des1 = DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64);
let des2 = DES::decryptor_with_key_u64(0x_FEDCBA0987654321_u64);
let des3 = DES::encryptor_with_key_u64(0x_1234567890ABCDEF_u64);
tdes.push_small_cryptor(des1);
tdes.push_small_cryptor(des2);
tdes.push_small_cryptor(des3);

§Example 5

use cryptocol::symmetric::{ BigCryptor64, DES };
let mut tdes = BigCryptor64::new();
let des1 = DES::encryptor_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
let des2 = DES::decryptor_with_key([0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21]);
let des3 = DES::encryptor_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
tdes.push_small_cryptor(des1);
tdes.push_small_cryptor(des2);
tdes.push_small_cryptor(des3);

Now, you can freely use any operation mode. This crate provide ECB (Electronic CodeBook), CBC(Cipher Block Chaining), PCBC (Propagation Cipher Block Chaining), CFB (Cipher FeedBack) OFB (Output FeedBack), and CTR (CounTeR). You can choose the way of padding bits according to either PKCS #7 or ISO 7816-4. So, you can import (use) one of the following traits: ECB_PKCS7, ECB_ISO, CBC_PKCS7, CBC_ISO, PCBC_PKCS7, PCBC_ISO, CFB, OFB, and CTR. The following example 6 shows the case that you choose CBC operation mode and padding bits according to PKCS #7.

§Example 6

use std::fmt::Write as _;
use cryptocol::symmetric::{ BigCryptor64, DES, CBC_PKCS7 };
let mut tdes = BigCryptor64::new()
                            + DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF])
                            - DES::new_with_key([0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21])
                            + DES::new_with_key([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
 
let iv = 0x_FEDCBA0987654321_u64;
println!("IV =	{:#018X}", iv);
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let mut cipher = Vec::<u8>::new();
tdes.encrypt_str_into_vec(iv, &message, &mut cipher);
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, "86 2B D7 BF 00 2E CD 70 ED 0C E3 8D 75 18 CE 0F BD A7 AE AF E5 19 46 F8 15 7A 24 0E CB 20 91 C0 03 B9 56 C5 77 01 33 E8 8E 84 CA B9 F2 99 63 AC 3A 3D 1F EF CA CA CB 67 ");

let mut recovered = String::new();
tdes.decrypt_into_string(iv, cipher.as_ptr(), cipher.len() as u64, &mut recovered);
println!("B =\t{}", recovered);
assert_eq!(recovered, "In the beginning God created the heavens and the earth.");
assert_eq!(recovered, message);

§Notice for Practical Use

Now, you can freely use any methods with any paddings in any operation modes.

This crate provides six operation modes: ECB, CBC, PCBC, CFB, OFB, and CTR.
This crate provides two padding ways: ISO 7816-4 and PKCS #7.
The operation modes ECB, CBC and PCBC requires padding bytes.
You can combine three operation modes and two padding ways.
The operation modes CFB, OFB, and CTR does not require padding bytes.
The traits that implements combination of operation modes and padding ways are provided such as ECB_PKCS7, ECB_ISO, CBC_PKCS7, CBC_ISO, PCBC_PKCS7, and PCBC_ISO.
You can find detaild instructions and their helpful examples if you go through those links.

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

Struct BigCryptor64 Copy item path

§Introduction

§Quick Start

§Example 1

§Example 2

§Example 3

§Example 4

§Example 5

§Example 6

§Notice for Practical Use

Implementations§

impl BigCryptor64

pub fn new() -> Self

§Output

§Features

§Example 1

§For more examples,

pub fn new_with_small_cryptor_array<const N: usize>( smallcryptor: [Box<dyn SmallCryptor64>; N], ) -> Self

§Arguments

§Output

§Features

§Example 1 for normal case

§For more examples,

pub fn new_with_small_cryptor_vec( smallcryptor: Vec<Box<dyn SmallCryptor64>>, ) -> Self

§Arguments

§Output

§Features

§Example 1 for normal case

§For more examples,

pub fn push_small_cryptor<S: SmallCryptor64 + 'static>( &mut self, smallcryptor: S, )

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn push_small_cryptor_array<const N: usize>( &mut self, smallcryptors: [Box<dyn SmallCryptor64>; N], )

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn push_small_cryptor_vec( &mut self, smallcryptor: Vec<Box<dyn SmallCryptor64>>, )

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn turn_inverse(&mut self)

§Features

§Example 1

§For more examples,

pub fn turn_encryptor(&mut self)

§Features

§Example 1

§For more examples,

pub fn turn_decryptor(&mut self)

§Features

§Example 1

§For more examples,

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

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

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

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

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

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

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

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

pub fn is_successful(&self) -> bool

§Output

§Features

§Example 1 for Successful case for encryption

Struct BigCryptor64

impl<S> Add<S> for BigCryptor64
where S: SmallCryptor64 + 'static,

fn encrypt( &mut self, iv: u64, message: const u8, length_in_bytes: u64, cipher: mut u8, ) -> u64

fn decrypt( &mut self, iv: u64, cipher: const u8, length_in_bytes: u64, message: mut u8, ) -> u64

fn encrypt_into_array<U, const N: usize>( &mut self, iv: u64, message: *const u8, length_in_bytes: u64, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_into_vec<U>( &mut self, iv: u64, message: *const u8, length_in_bytes: u64, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn decrypt_into_array<U, const N: usize>( &mut self, iv: u64, cipher: *const u8, length_in_bytes: u64, message: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_str_into_vec<U>( &mut self, iv: T, message: &str, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn encrypt_str_into_array<U, const N: usize>( &mut self, iv: T, message: &str, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_string_into_vec<U>( &mut self, iv: T, message: &String, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn encrypt_string_into_array<U, const N: usize>( &mut self, iv: T, message: &String, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_vec<U>(&mut self, iv: T, message: &Vec<U>, cipher: *mut u8) -> u64
where U: SmallUInt,

fn encrypt_vec_into_vec<U, V>( &mut self, iv: T, message: &Vec<U>, cipher: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_vec_into_array<U, V, const N: usize>( &mut self, iv: T, message: &Vec<U>, cipher: &mut [V; N], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_array<U, const N: usize>( &mut self, iv: T, message: &[U; N], cipher: *mut u8, ) -> u64
where U: SmallUInt,

fn encrypt_array_into_vec<U, V, const N: usize>( &mut self, iv: T, message: &[U; N], cipher: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_array_into_array<U, V, const N: usize, const M: usize>( &mut self, iv: T, message: &[U; N], cipher: &mut [V; M], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_into_vec<U>( &mut self, iv: T, cipher: *const u8, length_in_bytes: u64, message: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn decrypt_vec<U>(&mut self, iv: T, cipher: &Vec<U>, message: *mut u8) -> u64
where U: SmallUInt,

fn decrypt_vec_into_vec<U, V>( &mut self, iv: T, cipher: &Vec<U>, message: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_vec_into_array<U, V, const N: usize>( &mut self, iv: T, cipher: &Vec<U>, message: &mut [V; N], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_vec_into_string<U>( &mut self, iv: T, cipher: &Vec<U>, message: &mut String, ) -> u64
where U: SmallUInt,

fn decrypt_array<U, const N: usize>( &mut self, iv: T, cipher: &[U; N], message: *mut u8, ) -> u64
where U: SmallUInt,

fn decrypt_array_into_vec<U, V, const N: usize>( &mut self, iv: T, cipher: &[U; N], message: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_array_into_array<U, V, const N: usize, const M: usize>( &mut self, iv: T, cipher: &[U; N], message: &mut [V; M], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_array_into_string<U, const N: usize>( &mut self, iv: T, cipher: &[U; N], message: &mut String, ) -> u64
where U: SmallUInt,

fn encrypt( &mut self, iv: u64, message: const u8, length_in_bytes: u64, cipher: mut u8, ) -> u64

fn decrypt( &mut self, iv: u64, cipher: const u8, length_in_bytes: u64, message: mut u8, ) -> u64

fn encrypt_into_array<U, const N: usize>( &mut self, iv: u64, message: *const u8, length_in_bytes: u64, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_into_vec<U>( &mut self, iv: u64, message: *const u8, length_in_bytes: u64, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn decrypt_into_array<U, const N: usize>( &mut self, iv: u64, cipher: *const u8, length_in_bytes: u64, message: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_str_into_vec<U>( &mut self, iv: T, message: &str, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn encrypt_str_into_array<U, const N: usize>( &mut self, iv: T, message: &str, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_string_into_vec<U>( &mut self, iv: T, message: &String, cipher: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn encrypt_string_into_array<U, const N: usize>( &mut self, iv: T, message: &String, cipher: &mut [U; N], ) -> u64
where U: SmallUInt,

fn encrypt_vec<U>(&mut self, iv: T, message: &Vec<U>, cipher: *mut u8) -> u64
where U: SmallUInt,

fn encrypt_vec_into_vec<U, V>( &mut self, iv: T, message: &Vec<U>, cipher: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_vec_into_array<U, V, const N: usize>( &mut self, iv: T, message: &Vec<U>, cipher: &mut [V; N], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_array<U, const N: usize>( &mut self, iv: T, message: &[U; N], cipher: *mut u8, ) -> u64
where U: SmallUInt,

fn encrypt_array_into_vec<U, V, const N: usize>( &mut self, iv: T, message: &[U; N], cipher: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn encrypt_array_into_array<U, V, const N: usize, const M: usize>( &mut self, iv: T, message: &[U; N], cipher: &mut [V; M], ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_into_vec<U>( &mut self, iv: T, cipher: *const u8, length_in_bytes: u64, message: &mut Vec<U>, ) -> u64
where U: SmallUInt,

fn decrypt_vec<U>(&mut self, iv: T, cipher: &Vec<U>, message: *mut u8) -> u64
where U: SmallUInt,

fn decrypt_vec_into_vec<U, V>( &mut self, iv: T, cipher: &Vec<U>, message: &mut Vec<V>, ) -> u64
where U: SmallUInt, V: SmallUInt,

fn decrypt_vec_into_array<U, V, const N: usize>( &mut self, iv: T, cipher: &Vec<U>, message: &mut [V; N], ) -> u64
where U: SmallUInt, V: SmallUInt,