Struct Rijndael_Generic

Source

pub struct Rijndael_Generic<const ROUND: usize = 10, const NB: usize = 4, const NK: usize = 4, const IRREDUCIBLE: u8 = 27, const AFFINE_MUL: u64 = 17905254523795399665, const AFFINE_ADD: u8 = 99, const SR0: usize = 0, const SR1: usize = 1, const SR2: usize = 2, const SR3: usize = 3, const MC00: u8 = 2, const MC01: u8 = 3, const MC02: u8 = 1, const MC03: u8 = 1, const MC10: u8 = 1, const MC11: u8 = 2, const MC12: u8 = 3, const MC13: u8 = 1, const MC20: u8 = 1, const MC21: u8 = 1, const MC22: u8 = 2, const MC23: u8 = 3, const MC30: u8 = 3, const MC31: u8 = 1, const MC32: u8 = 1, const MC33: u8 = 2, const RC0: u32 = 1, const RC1: u32 = 2, const RC2: u32 = 4, const RC3: u32 = 8, const RC4: u32 = 16, const RC5: u32 = 32, const RC6: u32 = 64, const RC7: u32 = 128, const RC8: u32 = 27, const RC9: u32 = 54, const ROT: u32 = 1> { /* private fields */ }

Expand description

A Rijndael or AES (Advanced Encryption Standard) symmetric-key algorithm for the encryption of digital data

§Note

This descryption about Rijndael is according to little endianness. MSB (Most Significant Bit) is the 64th bit and LSB (Least Significant Bit) is the first bit in this descryption unless otherwise mentioned.

§Introduction

The name, AES, is the acronym of Advanced Encryption Standard. The name, Rijndael, is created out of the names of the Belgian cryptographers, Joan Daemen and Vincent Rijmen. Rijndael means Rhine valley in Dutch though it is not known whether the name Rijndael was made with that intention. AES is the subset of Rijndael. AES has three versions: AES-128, AES-192 and AES-256. All of them have the 128-bit data block. AES-128 has the 128-bit key length. AES-192 has the 192-bit key length. AES-256 has the 256-bit key length. On the other hand, Rijndael has nine versions: Rijndael-128-128, Rijndael-128-192, Rijndael-128-256, Rijndael-192-128, Rijndael-192-192, Rijndael-192-256, Rijndael-256-128, Rijndael-256-192, and Rijndael-256-256. Rijndael-128-, Rijndael-192-, and Rijndael-256-* have 128-bit data block, 192-bit data block, and 256-bit data block, respectively. Rijndael--128, Rijndael--192, and Rijndael-*-256 have 128-bit key length, 192-bit key length, and 256-bit key length, respectively. However, this module, Rijndael_Generic provides more expanded versions such as 32-bit and 64-bit data blocks and key lengths and more than 256-bit data blocks and key lengths.

§Short History of birth of AES

On 2nd, January, 1997, NIST announced that they wished to choose the encryption algorithm standard in replacement of DES, which is called AES.
The contest held three rounds. At the first round, fifteen were submitted: CAST-256, CRYPTON, DEAL, DFC, E2, FROG, HPC, LOKI97, MAGENTA, MARS, RC6, Rijndael, SAFER+, Serpent, and Twofish. At the second round, five remained: MARS, RC6, Rijndael, Serpent, and Twofish. At the third round, Rijndael was chosen out of the remained five. However, all the five algorithms are commonly referred to as “AES finalists”, and they are also considered well-known and respected in the community. So, the other four algorithms are also being actively used as well as Rijndael, today.

§Use of AES or Rijndael and its variants

This algorithm is implemented generic way. Most of the constants are implemented as generic constants. So, without changing any line of code, you can change the algorithm by changing the generic parameter. You can design and implement your own algorithm based on Rijndael which uses SPN (Substitution–Permutation Network). You can also use the the source code of Rijndael_Generic in order to find the weakness of SPN.

§Generic Parameters

You can change the generic parameters if you want to make your own encryption/decryption algorithm based on Rijndael. However, your own algorithm may or may not be securer than AES. It is a high chance that your own algorithm is less secure than AES unless you have performed the security test for your own algorithm and proved that your algorithm is at least as secure as AES.

ROUND: Indicates the number of rounds. You can change how many times the Substitution-Permutation Network will be repeated. Its minimum value is 0. Original Rijndael has the number of rounds as follows:

data \ key 128-bit key 192-bit key 256-bit key

128-bit data 10 rounds 12 rounds 14 rounds

192-bit data 12 rounds 12 rounds 14 rounds

256-bit data 14 rounds 14 rounds 14 rounds

The default of ROUND is 10. The default value 10 is for AES-128 which is most frequently used.
NB: Indicates the size of block. The block size is (NB * 4) bytes. You can change the size of block by changing the value NB. The default value of NB is 4. The default value 4 is for AES which is most frequently used. If NB is 0, the behavior is not defined.
NK: Indicates the size of key. The key size is (NK * 4) bytes. You can change the size of Key by changing the value NK. The default value of NK is 4. The default value 4 is for AES-128 which is most frequently used. If NK is 0, the behavior is not defined.
IRREDUCIBLE: Indicates the irreducible polynomial. You can change the irreducible polynomial by changing IRREDUCIBLE. The default value of IRREDUCIBLE is 0b_0001_1011 which means x^8 + x^4 + x^3 + x + 1. In IRREDUCIBLE, the term x^8 is always omitted. The default value 0b_0001_1011 is for Rijndael or AES.
AFFINE_MUL: Indicates the two-dimensional matrix that is used to make S-Box. AFFINE_MUL is the linear part of the affine transformation. You can change the S-Box by changing AFFINE_MUL with AFFINE_ADD along. The default value of AFFINE_MUL is 0b_11111000_01111100_00111110_00011111_10001111_11000111_11100011_11110001 which means the matrix as follows.

Matrix

1 1 1 1 1 0 0 0

0 1 1 1 1 1 0 0

0 0 1 1 1 1 1 0

0 0 0 1 1 1 1 1

1 0 0 0 1 1 1 1

1 1 0 0 0 1 1 1

1 1 1 0 0 0 1 1

1 1 1 1 0 0 0 1

The default value of AFFINE_MUL is for Rijndael or AES.
AFFINE_ADD: Indicates the one-dimensional matrix that is used to make S-Box. AFFINE_ADD is the non-linear part of the affine transformation. You can change the S-Box by changing AFFINE_ADD with AFFINE_MUL along. The default value of AFFINE_ADD is 0b_01100011 which means the matrix as follows.

Matrix

0

1

1

0

0

0

1

1

The default value of AFFINE_ADD is for Rijndael or AES.
SR0 ~ SR3: Indicates how many bytes to shift (rotate) in each row in ShiftRows step. You can change the amounts of shifting (rotating) in each row by changing SR0, SR1, SR2, and SR3. The default values of SR0, SR1, SR2, and SR3 are 0, 1, 2, and 3, respectively. The default values 0, 1, 2, and 3 are for Rijndael or AES.
MC00 ~ MC33: Indicates the two-dimensional matrix that is used as MixColumns matrix in MixColumn step. MC00, MC01, MC02, MC03, MC10, MC11, MC12, MC13, MC20, MC21, MC22, MC23, MC30, MC31, MC32, and MC33 are the elements of the two-dimensional MixColumns matrix. You can change the MixColumns matrix to change the MixColumn step by changing MC00 ~ MC33. The default values of MC00, MC01, MC02, MC03, MC10, MC11, MC12, MC13, MC20, MC21, MC22, MC23, MC30, MC31, MC32, and MC33 are 2, 3, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 3, 1, 1, and 2, respectively, which means the matrix as follows.

Matrix

2 3 1 1

1 2 3 1

1 1 2 3

3 1 1 2

The default values of MC00 ~ MC33 are for Rijndael or AES.
RC0 ~ RC9: Indicates Round Constants that are used to make round keys. The round keys are used in the AddRoundKey step. You can change the round keys by changing RC0 ~ RC9. The default values of RC0, RC1, RC2, RC3, RC4, RC5, RC6, RC7, RC8, and RC9 are 0b_0000_0001, 0b_0000_0010, 0b_0000_0100, 0b_0000_1000, 0b_0001_0000, 0b_0010_0000,0b_0100_0000, 0b_1000_0000, 0b_0001_1011, and 0b_001_10110, respectively. The default values are for Rijndael or AES. If Round is greater than 10, the round constants after RC9 will be determined by multiplying previous round constant by 2 on Galois Field. So, So-called RC10 is double of RC9 on Galois Field and RC11 is double of RC10 on Galois Field, and so on.
ROT: Indicates how may bytes to shift (rotate) in making round keys. You can change round keys by changing ROT. The default value of ROT is 1. The default value 1 is for for Rijndael or AES.

§Reference

Read more about AES in brief. Watch this video and then this video in series for more (or deeper or full) understanding of AES.

§Quick Start

You have to import (use) one of the modules: AES_128, AES_192, and AES_256 in order to use official AES as shown in Example 1. And, in the same way you can import (use) the modules: Rijndael_128_128, Rijndael_128_192, Rijndael_128_256, Rijndael_128_384, Rijndael_128_512, Rijndael_192_128, Rijndael_192_192, Rijndael_192_256, Rijndael_192_384, Rijndael_192_512, Rijndael_256_128, Rijndael_256_192, Rijndael_256_256, Rijndael_256_384, Rijndael_256_512, Rijndael_384_128, Rijndael_384_192, Rijndael_384_256, Rijndael_384_384, Rijndael_384_512, Rijndael_512_128, Rijndael_512_192, Rijndael_512_256, Rijndael_512_384, and Rijndael_512_512. Of course, you can also expand Rijndael by changing the generic parameters. Also, there are some predefined modules: Rijndael_32_32 for 32 bit key and 32-bit encryption data, and Rijndael_64_64 for 64 bit key and 64-bit encryption data for educational purpose, though they are not very practical.

§Example 1

use cryptocol::symmetric::AES_128;
use cryptocol::symmetric::AES_192;
use cryptocol::symmetric::AES_256;
 
use cryptocol::symmetric::Rijndael_128_128;
use cryptocol::symmetric::Rijndael_128_192;
use cryptocol::symmetric::Rijndael_128_256;
use cryptocol::symmetric::Rijndael_128_384;
use cryptocol::symmetric::Rijndael_128_512;
 
use cryptocol::symmetric::Rijndael_192_128;
use cryptocol::symmetric::Rijndael_192_192;
use cryptocol::symmetric::Rijndael_192_256;
use cryptocol::symmetric::Rijndael_192_384;
use cryptocol::symmetric::Rijndael_192_512;
 
use cryptocol::symmetric::Rijndael_256_128;
use cryptocol::symmetric::Rijndael_256_192;
use cryptocol::symmetric::Rijndael_256_256;
use cryptocol::symmetric::Rijndael_256_384;
use cryptocol::symmetric::Rijndael_256_512;
 
use cryptocol::symmetric::Rijndael_384_128;
use cryptocol::symmetric::Rijndael_384_192;
use cryptocol::symmetric::Rijndael_384_256;
use cryptocol::symmetric::Rijndael_384_384;
use cryptocol::symmetric::Rijndael_384_512;
 
use cryptocol::symmetric::Rijndael_512_128;
use cryptocol::symmetric::Rijndael_512_192;
use cryptocol::symmetric::Rijndael_512_256;
use cryptocol::symmetric::Rijndael_512_384;
use cryptocol::symmetric::Rijndael_512_512;
 
use cryptocol::symmetric::Rijndael_64_64;
use cryptocol::symmetric::Rijndael_32_32;

You can instantiate the AES object with u128 key as Example 2. In this case, you have to take endianness into account. In little-endianness, 0x_1234567890ABCDEF1234567890ABCDEF_u128 is [0xEFu8, 0xCDu8, 0xABu8, 0x90u8, 0x78u8, 0x56u8, 0x34u8, 0x12u8, 0xEFu8, 0xCDu8, 0xABu8, 0x90u8, 0x78u8, 0x56u8, 0x34u8, 0x12u8] while the same 0x_1234567890ABCDEF1234567890ABCDEF_u128 is [0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x90u8, 0xABu8, 0xCDu8, 0xEF_u64, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x90u8, 0xABu8, 0xCDu8, 0xEF_u64] in big-endianness. The instantiated object should be mutable.

§Example 2

use cryptocol::symmetric::AES_128;
let key = 0x_1234567890ABCDEF1234567890ABCDEF_u128;
let mut _a_aes = AES_128::new_with_key_u128(key);

Note that the object should be intantiated as mutable object. Also, you can instantiate the AES object with [u8; 16] key 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::AES_128;
let key = [0xEFu8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12];
let mut _a_aes = AES_128::new_with_key(&key);

You can instantiate the AES object without key and set a u128 key later as shown in Example 4 or a [u8; 16] key later as shown in Example 5.

§Example 4

use cryptocol::symmetric::AES_128;
let mut a_aes = AES_128::new();
let key = 0x_1234567890ABCDEF1234567890ABCDEF_u128;
a_aes.set_key_u128(key);

§Example 5

use cryptocol::symmetric::AES_128;
let mut a_aes = AES_128::new();
let key = [0xEFu8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12];
a_aes.set_key(&key);

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::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ AES_128, CBC_PKCS7 };

let mut a_aes = AES_128::new_with_key(&[0xEFu8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]);
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let iv = [0x87654321_u32, 0xFEDCBA09_u32, 0x87654321_u32, 0xFEDCBA09_u32];
println!("IV =\t{:08X}{:08X}{:08X}{:08X}", iv[0].to_be(), iv[1].to_be(), iv[2].to_be(), iv[3].to_be());
let mut cipher = Vec::<u8>::new();
a_aes.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, "C9 1C 27 CE 83 92 A1 CF 7D A4 64 35 16 48 01 72 CC E3 6D CD BB 19 FC D0 80 22 09 9F 23 32 73 27 58 37 F9 9B 3C 44 7B 03 B3 80 7E 99 DF 97 4E E9 A3 89 67 0C 21 29 3E 4D DC AD B6 44 09 D4 3B 02 ");

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

You can modify the Rijndael encryption/decryption algorithm as you want. All the constants are implemented as generic parameters. For instance, you can change S-box, the number of rounds of Substitution - Permutation network, the irreducible polynormial, key length, etc. The following Example 7 shows the variation of Rijndael which has 512-bit data block and 512-bit key.

§Example 7

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::symmetric::{ Rijndael_Generic, CBC_PKCS7 };

let mut a_rijndael = Rijndael_Generic::<22, 16, 16>::new_with_key(&[0xEFu8, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]);
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let iv = [0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32, 0x_FEDCBA09_u32, 87654321_u32];
println!("IV =\t{:08X}{:08X}{:08X}{:08X}", iv[0].to_be(), iv[1].to_be(), iv[2].to_be(), iv[3].to_be());

let mut cipher = Vec::<u8>::new();
a_rijndael.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, "B1 C0 1F 84 17 46 35 12 D9 16 52 44 5F 40 A1 7F 3B 55 F7 E6 42 E5 1F 42 57 43 AD E4 00 19 54 1D B6 F3 1B 20 C8 D3 08 92 B7 C4 0C E2 77 73 A5 E4 0D E7 0F F4 B0 38 FE 78 30 56 E4 A7 9E CE 0E 50 ");

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

You can use Rijndael_512_512 as one of post-Quantum algorithms for a while because even Grover algorithm takes long enough to break Rijndael_512_512. Its key is 512-bit and its encryption block is 512-bit.

§Example 8 for Post-Quantum

use std::io::Write;
use std::fmt::Write as _;
use cryptocol::number::SharedArrays;
use cryptocol::hash::SHA3_512;
use cryptocol::symmetric::{ Rijndael_512_512, CBC_ISO };
 
let mut sha3 = SHA3_512::new();
sha3.absorb_str("Post-Quantum");
let key: [u8; 64] = sha3.get_hash_value_in_array();
print!("K =\t");
for i in 0..64
    { print!("{:02X}", key[i]); }
println!();
let mut a_rijndael = Rijndael_512_512::new_with_key(&key);
sha3.absorb_str("Initialize");
let mut iv = SharedArrays::<u32, 16, u8, 64>::new();
iv.src = sha3.get_hash_value_in_array();
let iv = unsafe { iv.des };
print!("IV =\t");
for i in 0..16
    { print!("{:08X}", iv[i].to_be()); }
println!();
let message = "In the beginning God created the heavens and the earth.";
println!("M =\t{}", message);
let mut cipher = [0_u8; 64];
a_rijndael.encrypt(iv.clone(), message.as_ptr(), message.len() as u64, cipher.as_mut_ptr());
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, "C2 C4 1C 91 EE 50 F0 04 B6 73 00 B2 81 05 01 25 C1 87 24 27 7E CE 01 65 C5 CB 87 38 99 9F 5B 0C D1 DF 8D 52 C4 C4 C8 D8 F5 D5 AD F3 FD DA 35 C2 33 F6 5D 83 02 85 F1 20 8C 56 0B 72 9C 91 84 42 ");
 
let mut recovered = vec![0; 55];
a_rijndael.decrypt(iv, cipher.as_ptr(), cipher.len() as u64, recovered.as_mut_ptr());
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, "49 6E 20 74 68 65 20 62 65 67 69 6E 6E 69 6E 67 20 47 6F 64 20 63 72 65 61 74 65 64 20 74 68 65 20 68 65 61 76 65 6E 73 20 61 6E 64 20 74 68 65 20 65 61 72 74 68 2E ");
 
let mut converted = String::new();
unsafe { converted.as_mut_vec() }.append(&mut recovered);
 
println!("Bb =\t{}", converted);
assert_eq!(converted, "In the beginning God created the heavens and the earth.");
assert_eq!(converted, 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

data \ key	128-bit key	192-bit key	256-bit key
128-bit data	10 rounds	12 rounds	14 rounds
192-bit data	12 rounds	12 rounds	14 rounds
256-bit data	14 rounds	14 rounds	14 rounds

Matrix
1 1 1 1 1 0 0 0
0 1 1 1 1 1 0 0
0 0 1 1 1 1 1 0
0 0 0 1 1 1 1 1
1 0 0 0 1 1 1 1
1 1 0 0 0 1 1 1
1 1 1 0 0 0 1 1
1 1 1 1 0 0 0 1

Matrix
0
1
1
0
0
0
1
1

Matrix
2 3 1 1
1 2 3 1
1 1 2 3
3 1 1 2

Struct Rijndael_Generic Copy item path

§Note

§Introduction

§Short History of birth of AES

§Use of AES or Rijndael and its variants

§Generic Parameters

§Reference

§Quick Start

§Example 1

§Example 2

§Example 3

§Example 4

§Example 5

§Example 6

§Example 7

§Example 8 for Post-Quantum

§Notice for Practical Use

Implementations§

pub fn new() -> Self

§Features

§Example 1

§For more examples,

pub fn box_new() -> Box<Self>

§Features

§Example 1

§For more examples,

pub fn new_with_key<const K: usize>(key: &[u8; K]) -> Self

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn new_with_key_u128(key: u128) -> Self

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn encryptor_with_key<const K: usize>(key: &[u8; K]) -> Self

§Arguments

§Features

§Example 1

§For more examples,

pub fn encryptor_with_key_u128(key: u128) -> Self

§Arguments

§Features

§Example 1

§For more examples,

pub fn decryptor_with_key<const K: usize>(key: &[u8; K]) -> Self

§Arguments

§Features

§Example 1

§For more examples,

pub fn decryptor_with_key_u128(key: u128) -> Self

§Arguments

§Features

§Example 1

§For more examples,

pub fn get_key(&mut self) -> [u32; NK]

§Output

§Example 1 for AES_128

§For more examples,

pub fn get_key_u128(&self) -> u128

§Output

§Features

§Example 1 for 128-bit key

§For more examples,

pub fn set_key<const K: usize>(&mut self, key: &[u8; K])

§Arguments

§Features

§Example 1 for normal case

§For more examples,

pub fn set_key_u128(&mut self, key: u128)

§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)

Struct Rijndael_Generic