Change FeedbackSize on Rijndael wrappers to delegate to implementation.

The FeedbackSize on RijndaelManaged and RijndaelImplementation were not
accurately reflecting the feedback size that the actual implementation
was using. The FeedbackSize would report 128, however the implementation
defaults to 8, so CFB8 is actually what was being used.

Likewise, the setter for FeedbackSize on the Rijndael types had no
effect. The implementation's default feedback size of 8 would always
be used.

src/libraries/System.Security.Cryptography.Algorithms/src/Internal/Cryptography/RijndaelImplementation.cs

@@ -23,6 +23,7 @@ internal RijndaelImplementation()
 
             // This class wraps Aes
             _impl = Aes.Create();
+            _impl.FeedbackSize = 128;
         }
 
         public override int BlockSize
@@ -42,6 +43,12 @@ public override int BlockSize
             }
         }
 
+        public override int FeedbackSize
+        {
+            get => _impl.FeedbackSize;
+            set => _impl.FeedbackSize = value;
+        }
+
         public override byte[] IV
         {
             get { return _impl.IV; }

src/libraries/System.Security.Cryptography.Algorithms/src/System/Security/Cryptography/RijndaelManaged.cs

@@ -19,6 +19,7 @@ public RijndaelManaged()
 
             // This class wraps Aes
             _impl = Aes.Create();
+            _impl.FeedbackSize = 128;
         }
 
         public override int BlockSize
@@ -38,6 +39,12 @@ public override int BlockSize
             }
         }
 
+        public override int FeedbackSize
+        {
+            get => _impl.FeedbackSize;
+            set => _impl.FeedbackSize = value;
+        }
+
         public override byte[] IV
         {
             get { return _impl.IV; }

src/libraries/System.Security.Cryptography.Algorithms/tests/RijndaelTests.cs

@@ -25,13 +25,15 @@ static void test(Rijndael alg)
                 Assert.Equal(128, alg.LegalBlockSizes[0].MinSize);
                 Assert.Equal(128, alg.LegalBlockSizes[0].MaxSize);
                 Assert.Equal(128, alg.BlockSize);
+                Assert.Equal(128, alg.FeedbackSize);
 
                 // Different exception since we have different supported BlockSizes than desktop
                 Assert.Throws<PlatformNotSupportedException>(() => alg.BlockSize = 192);
                 Assert.Throws<PlatformNotSupportedException>(() => alg.BlockSize = 256);
 
                 // Normal exception for rest
                 Assert.Throws<CryptographicException>(() => alg.BlockSize = 111);
+                Assert.Throws<CryptographicException>(() => alg.FeedbackSize = 15);
 
                 Assert.Equal(CipherMode.CBC, alg.Mode);
                 Assert.Equal(PaddingMode.PKCS7, alg.Padding);
@@ -169,6 +171,9 @@ static void test(Rijndael alg)
 
                 alg.Padding = PaddingMode.PKCS7;
                 Assert.Equal(PaddingMode.PKCS7, alg.Padding);
+
+                alg.FeedbackSize = 8;
+                Assert.Equal(8, alg.FeedbackSize);
             }
 
             using (var alg = Rijndael.Create())
@@ -291,6 +296,51 @@ public static void MultipleBlockDecryptTransform(bool blockAlignedOutput)
             Assert.Equal(ExpectedOutput, decrypted);
         }
 
+        [Theory]
+        [InlineData(128)]
+        [InlineData(8)]
+        [InlineData(null)]
+        public static void CfbFeedbackSizeIsRespected(int? feedbackSize)
+        {
+            // Windows 7 CFB only supports CFB8.
+            if (PlatformDetection.IsWindows7 && feedbackSize != 8)
+                return;
+
+            void Test(Rijndael alg)
+            {
+                alg.Mode = CipherMode.CFB;
+
+                if (feedbackSize == null)
+                {
+                    feedbackSize = alg.FeedbackSize;
+                }
+                else
+                {
+                    alg.FeedbackSize = feedbackSize.Value;
+                }
+
+                int feedbackSizeBytes = feedbackSize.Value / 8;
+                byte[] input = new byte[feedbackSizeBytes + 1];
+
+                using ICryptoTransform transform = alg.CreateEncryptor();
+
+                byte[] output = transform.TransformFinalBlock(input, 0, input.Length);
+                int expectedOutputSize = (input.Length / feedbackSizeBytes) * feedbackSizeBytes + feedbackSizeBytes;
+
+                Assert.Equal(expectedOutputSize, output.Length);
+            }
+
+            using (Rijndael alg = new RijndaelManaged())
+            {
+                Test(alg);
+            }
+
+            using (Rijndael alg = Rijndael.Create())
+            {
+                Test(alg);
+            }
+        }
+
         private class RijndaelLegalSizesBreaker : RijndaelMinimal
         {
             public RijndaelLegalSizesBreaker()