Struct BigCryptor128

Source

pub struct BigCryptor128 { /* private fields */ }

Expand description

A BigCryptor128 wrapper struct for cascading encryption/decryption algorithms that has 128-bit block size

§Introduction

BigCryptor128 is mainly used to make cascade encryption/decryption that has 128-bit block size.

§Quick Start

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

§Example 1

use cryptocol::symmetric::BigCryptor128;

You can instantiate the BigCryptor128 object with components (hereinafter, referred to as small cryptor) that has u128 keys as Example 2, for example. In this case, you have to take endianness into account. In little-endianness, 0x_1234567890ABCDEFFEDCBA0987654321_u128 is [0x21u8, 0x43, 0x65, 0x87, 0x09, 0xBA, 0xDC, 0xFE, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12] while the same 0x_1234567890ABCDEFFEDCBA0987654321_u128 is [0x12u8, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21] in big-endianness. The instantiated object should be mutable.

§Example 2

use cryptocol::symmetric::{ BigCryptor128, AES_128 };
let mut _taes = BigCryptor128::new()
                + AES_128::encryptor_with_key_u128(0x_1234567890ABCDEFFEDCBA0987654321_u128)
                + AES_128::decryptor_with_key_u128(0x_FEDCBA09876543211234567890ABCDEF_u128)
                + AES_128::encryptor_with_key_u128(0x_1234567890ABCDEFFEDCBA0987654321_u128);

Also, you can instantiate the BigCryptor128 object with small cryptors (component) that have [u8; 16] 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::{ BigCryptor128, AES_128 };
let mut _taes = BigCryptor128::new()
                + AES_128::new_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21])
                - AES_128::new_with_key(&[0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF])
                + AES_128::new_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21]);

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

§Example 4

use cryptocol::symmetric::{ BigCryptor128, AES_128 };
let mut taes = BigCryptor128::new();
let aes1 = AES_128::encryptor_with_key_u128(0x_1234567890ABCDEFFEDCBA0987654321_u128);
let aes2 = AES_128::decryptor_with_key_u128(0x_FEDCBA09876543211234567890ABCDEF_u128);
let aes3 = AES_128::encryptor_with_key_u128(0x_1234567890ABCDEFFEDCBA0987654321_u128);
taes.push_small_cryptor(aes1);
taes.push_small_cryptor(aes2);
taes.push_small_cryptor(aes3);

§Example 5

use cryptocol::symmetric::{ BigCryptor128, AES_128 };
let mut taes = BigCryptor128::new();
let aes1 = AES_128::encryptor_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21]);
let aes2 = AES_128::decryptor_with_key(&[0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
let aes3 = AES_128::encryptor_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21]);
taes.push_small_cryptor(aes1);
taes.push_small_cryptor(aes2);
taes.push_small_cryptor(aes3);

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::{ BigCryptor128, AES_128, CBC_PKCS7 };
let mut taes = BigCryptor128::new()
                + AES_128::new_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21])
                - AES_128::new_with_key(&[0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF])
                + AES_128::new_with_key(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x09, 0x87, 0x65, 0x43, 0x21]);
 
let iv = 0x_FEDCBA09876543211234567890ABCDEF_u128;
println!("IV =	{:#034X}", iv);
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let mut cipher = Vec::<u8>::new();
taes.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, "1E 24 26 AD 13 7F 6F 6A CD 22 3A 4F A5 24 D8 E0 E3 6A B2 39 0D 82 2B 6E 7B D6 95 09 6D EF C2 7B 30 53 87 B7 9C D3 21 7C C0 85 11 74 28 7B 98 7B 9F 02 54 81 23 96 6D F5 A1 39 C8 A2 4B 20 76 7A ");
/// let mut recovered = String::new();
taes.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 BigCryptor128 Copy item path

§Introduction

§Quick Start

§Example 1

§Example 2

§Example 3

§Example 4

§Example 5

§Example 6

§Notice for Practical Use

Implementations§

impl BigCryptor128

pub fn new() -> Self

§Output

§Features

§Example 1

§For more examples,

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

§Arguments

§Output

§Features

§Example 1 for normal case

§For more examples,

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

§Arguments

§Output

§Features

§Example 1 for normal case

§For more examples,

pub fn push_small_cryptor<S: SmallCryptor128 + '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, smallcryptor: [Box<dyn SmallCryptor128>; N], )

§Arguments

§Features

§Example 1 for normal case

§For more examples,

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

§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_u128(&mut self, message: u128) -> u128

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

pub fn decrypt_u128(&mut self, cipher: u128) -> u128

§Arguments

§Output

§Example 1 for Normal case

§For more examples,

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

§Arguments

§Example 1 for Normal case

§For more examples,

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

§Arguments

§Example 1 for Normal case

§For more examples,

pub fn is_successful(&self) -> bool

§Output

§Features

§Example 1 for Normal case for Successful case for encryption

§For more examples,

pub fn is_failed(&self) -> bool

Struct BigCryptor128

impl<S> Add<S> for BigCryptor128
where S: SmallCryptor128 + 'static,

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

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

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

fn encrypt_into_vec<U>( &mut self, iv: u128, 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: u128, 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: u128, message: const u8, length_in_bytes: u64, cipher: mut u8, ) -> u64

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

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

fn encrypt_into_vec<U>( &mut self, iv: u128, 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: u128, 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,