Add the ability to increase the number of Feistel Rounds

src/ff1.rs

@@ -22,6 +22,9 @@ pub use self::alloc::{BinaryNumeralString, FlexibleNumeralString};
 #[cfg(test)]
 mod test_vectors;
 
+#[cfg(test)]
+mod ff1_18;
+
 /// The minimum allowed numeral string length for any radix.
 const MIN_NS_LEN: u32 = 2;
 /// The maximum allowed numeral string length for any radix.
@@ -232,24 +235,35 @@ fn generate_s<'a, CIPH: BlockEncrypt>(
         .take(d)
 }
 
+/// A struct for performing FF1 encryption and decryption operations
+/// using the default 10 Feistel rounds
+pub type FF1<CIPH> = FF1fr<10, CIPH>;
+
+/// A struct for performing hardened FF1 encryption and decryption operations
+/// using 18 Feistel rounds
+pub type FF1h<CIPH> = FF1fr<18, CIPH>;
+
 /// A struct for performing FF1 encryption and decryption operations.
-pub struct FF1<CIPH: BlockCipher> {
+/// with an adjustable number of Feistel rounds
+pub struct FF1fr<const FEISTEL_ROUNDS: u8, CIPH: BlockCipher> {
     ciph: CIPH,
     radix: Radix,
 }
 
-impl<CIPH: BlockCipher + KeyInit> FF1<CIPH> {
+impl<const FEISTEL_ROUNDS: u8, CIPH: BlockCipher + KeyInit> FF1fr<FEISTEL_ROUNDS, CIPH> {
     /// Creates a new FF1 object for the given key and radix.
     ///
     /// Returns an error if the given radix is not in [2..2^16].
     pub fn new(key: &[u8], radix: u32) -> Result<Self, InvalidRadix> {
         let ciph = CIPH::new(GenericArray::from_slice(key));
         let radix = Radix::from_u32(radix)?;
-        Ok(FF1 { ciph, radix })
+        Ok(FF1fr { ciph, radix })
     }
 }
 
-impl<CIPH: BlockCipher + BlockEncrypt + Clone> FF1<CIPH> {
+impl<const FEISTEL_ROUNDS: u8, CIPH: BlockCipher + BlockEncrypt + Clone>
+    FF1fr<FEISTEL_ROUNDS, CIPH>
+{
     /// Encrypts the given numeral string.
     ///
     /// Returns an error if the numeral string is not in the required radix.
@@ -294,7 +308,7 @@ impl<CIPH: BlockCipher + BlockEncrypt + Clone> FF1<CIPH> {
         for _ in 0..((((-(t as i32) - (b as i32) - 1) % 16) + 16) % 16) {
             prf.update(&[0]);
         }
-        for i in 0..10 {
+        for i in 0..FEISTEL_ROUNDS {
             let mut prf = prf.clone();
             prf.update(&[i]);
             prf.update(x_b.num_radix(self.radix.to_u32()).to_bytes(b).as_ref());
@@ -372,8 +386,8 @@ impl<CIPH: BlockCipher + BlockEncrypt + Clone> FF1<CIPH> {
         for _ in 0..((((-(t as i32) - (b as i32) - 1) % 16) + 16) % 16) {
             prf.update(&[0]);
         }
-        for i in 0..10 {
-            let i = 9 - i;
+        for i in 0..FEISTEL_ROUNDS {
+            let i = FEISTEL_ROUNDS - 1 - i;
             let mut prf = prf.clone();
             prf.update(&[i]);
             prf.update(x_a.num_radix(self.radix.to_u32()).to_bytes(b).as_ref());

src/ff1/ff1_18.rs

@@ -0,0 +1,19 @@
+use aes::Aes256;
+
+use crate::ff1::{BinaryNumeralString, FF1h};
+
+#[test]
+fn test_doc_example_18_rounds() {
+    let key = [0; 32];
+    let radix = 2;
+    let pt = [0xab, 0xcd, 0xef];
+
+    let ff = FF1h::<Aes256>::new(&key, radix).unwrap();
+    let ct = ff
+        .encrypt(&[], &BinaryNumeralString::from_bytes_le(&pt))
+        .unwrap();
+    assert_eq!(ct.to_bytes_le(), [0x5a, 0x6c, 0x20]);
+
+    let p2 = ff.decrypt(&[], &ct).unwrap();
+    assert_eq!(p2.to_bytes_le(), pt);
+}