fix: restore missing method signatures accidentally overwritten in CbcBlockCipher and AesEngine

KonradSop · KonradSop · commit 26f21553b76f · 2026-04-01T22:53:40.000+02:00
diff --git a/crypto/src/crypto/engines/AesEngine.cs b/crypto/src/crypto/engines/AesEngine.cs
@@ -6,22 +6,30 @@
 
 namespace Org.BouncyCastle.Crypto.Engines
 {
-    /// <summary>
-    /// Implementation of the Advanced Encryption Standard (AES), also known as Rijndael, according to FIPS-197.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// For further details see: <a href="http://csrc.nist.gov/encryption/aes/">http://csrc.nist.gov/encryption/aes/</a>.
-    /// </para>
-    /// <para>
-    /// This implementation is based on optimizations from Dr. Brian Gladman's paper and C code at
-    /// <a href="http://fp.gladman.plus.com/cryptography_technology/rijndael/">http://fp.gladman.plus.com/cryptography_technology/rijndael/</a>.
-    /// </para>
-    /// <para>
-    /// This specific implementation uses a middle-performance approach with 2Kbytes of static tables 
-    /// for round precomputation, providing a balanced trade-off between speed and memory footprint.
-    /// </para>
-    /// </remarks>
+    /**
+    * an implementation of the AES (Rijndael), from FIPS-197.
+    * <p>
+    * For further details see: <a href="http://csrc.nist.gov/encryption/aes/">http://csrc.nist.gov/encryption/aes/</a>.
+    *
+    * This implementation is based on optimizations from Dr. Brian Gladman's paper and C code at
+    * <a href="http://fp.gladman.plus.com/cryptography_technology/rijndael/">http://fp.gladman.plus.com/cryptography_technology/rijndael/</a>
+    *
+    * There are three levels of tradeoff of speed vs memory
+    * Because java has no preprocessor, they are written as three separate classes from which to choose
+    *
+    * The fastest uses 8Kbytes of static tables to precompute round calculations, 4 256 word tables for encryption
+    * and 4 for decryption.
+    *
+    * The middle performance version uses only one 256 word table for each, for a total of 2Kbytes,
+    * adding 12 rotate operations per round to compute the values contained in the other tables from
+    * the contents of the first.
+    *
+    * The slowest version uses no static tables at all and computes the values in each round.
+    * </p>
+    * <p>
+    * This file contains the middle performance version with 2Kbytes of static tables for round precomputation.
+    * </p>
+    */
     public sealed class AesEngine
         : IBlockCipher
     {
@@ -429,19 +437,21 @@ private uint[][] GenerateWorkingKey(KeyParameter keyParameter, bool forEncryptio
 
         private const int BLOCK_SIZE = 16;
 
-        /// <summary>
-        /// Default constructor. Initializes an AES engine with a 128-bit block size.
-        /// </summary>
+        /**
+        * default constructor - 128 bit block size.
+        */
         public AesEngine()
         {
         }
 
-        /// <summary>
-        /// Initialise the AES engine.
-        /// </summary>
-        /// <param name="forEncryption">True if initialising for encryption, false for decryption.</param>
-        /// <param name="parameters">The key parameters, typically a <see cref="KeyParameter"/>.</param>
-        /// <exception cref="ArgumentException">If the parameters are inappropriate for AES.</exception>
+        /**
+        * initialise an AES cipher.
+        *
+        * @param forEncryption whether or not we are for encryption.
+        * @param parameters the parameters required to set up the cipher.
+        * @exception ArgumentException if the parameters argument is
+        * inappropriate.
+        */
         public void Init(bool forEncryption, ICipherParameters parameters)
         {
             if (!(parameters is KeyParameter keyParameter))
@@ -454,25 +464,17 @@ public void Init(bool forEncryption, ICipherParameters parameters)
             this.s = Arrays.Clone(forEncryption ? S : Si);
         }
 
-        /// <summary>The name of the algorithm this engine implements.</summary>
+        public string AlgorithmName
         {
             get { return "AES"; }
         }
 
-        /// <summary>Return the block size for this cipher (in bytes).</summary>
-        /// <returns>16 (fixed block size for AES).</returns>
+        public int GetBlockSize()
         {
             return BLOCK_SIZE;
         }
 
-        /// <summary>Process a single block of data.</summary>
-        /// <param name="input">The input buffer containing the data to be processed.</param>
-        /// <param name="inOff">The offset into the input buffer.</param>
-        /// <param name="output">The output buffer to write the processed data to.</param>
-        /// <param name="outOff">The offset into the output buffer.</param>
-        /// <returns>The number of bytes processed and produced (16).</returns>
-        /// <exception cref="InvalidOperationException">If the engine is not initialized.</exception>
-        /// <exception cref="DataLengthException">If input buffer is too short, or output buffer too small.</exception>
+        public int ProcessBlock(byte[] input, int inOff, byte[] output, int outOff)
         {
             if (WorkingKey == null)
                 throw new InvalidOperationException("AES engine not initialised");
@@ -504,12 +506,7 @@ public void Init(bool forEncryption, ICipherParameters parameters)
         }
 
 #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-        /// <summary>Process a single block of data using Spans.</summary>
-        /// <param name="input">The input span containing the data to be processed.</param>
-        /// <param name="output">The output span to write the processed data to.</param>
-        /// <returns>The number of bytes processed and produced (16).</returns>
-        /// <exception cref="InvalidOperationException">If the engine is not initialized.</exception>
-        /// <exception cref="DataLengthException">If input span is too short, or output span too small.</exception>
+        public int ProcessBlock(ReadOnlySpan<byte> input, Span<byte> output)
         {
             if (WorkingKey == null)
                 throw new InvalidOperationException("AES engine not initialised");
diff --git a/crypto/src/crypto/modes/CbcBlockCipher.cs b/crypto/src/crypto/modes/CbcBlockCipher.cs
@@ -5,9 +5,9 @@
 
 namespace Org.BouncyCastle.Crypto.Modes
 {
-    /// <summary>
-    /// Implements Cipher-Block-Chaining (CBC) mode on top of a simple block cipher.
-    /// </summary>
+    /**
+    * implements Cipher-Block-Chaining (CBC) mode on top of a simple cipher.
+    */
     public sealed class CbcBlockCipher
 		: IBlockCipherMode
     {
@@ -16,10 +16,11 @@ public sealed class CbcBlockCipher
         private IBlockCipher	cipher;
         private bool			encrypting;
 
-        /// <summary>
-        /// Basic constructor.
-        /// </summary>
-        /// <param name="cipher">The block cipher to be used as the basis of chaining.</param>
+        /**
+        * Basic constructor.
+        *
+        * @param cipher the block cipher to be used as the basis of chaining.
+        */
         public CbcBlockCipher(
             IBlockCipher cipher)
         {
@@ -31,18 +32,23 @@ public CbcBlockCipher(
             this.cbcNextV = new byte[blockSize];
         }
 
-        /// <summary>
-        /// Return the underlying block cipher that we are wrapping.
-        /// </summary>
+        /**
+        * return the underlying block cipher that we are wrapping.
+        *
+        * @return the underlying block cipher that we are wrapping.
+        */
         public IBlockCipher UnderlyingCipher => cipher;
 
-        /// <summary>
-        /// Initialise the cipher and, possibly, the initialisation vector (IV).
-        /// If an IV isn't passed as part of the parameter, the IV will be all zeros.
-        /// </summary>
-        /// <param name="forEncryption">If true the cipher is initialised for encryption, if false for decryption.</param>
-        /// <param name="parameters">The key and other data required by the cipher (typically <see cref="ParametersWithIV"/>).</param>
-        /// <exception cref="ArgumentException">If the parameters are inappropriate.</exception>
+        /**
+        * Initialise the cipher and, possibly, the initialisation vector (IV).
+        * If an IV isn't passed as part of the parameter, the IV will be all zeros.
+        *
+        * @param forEncryption if true the cipher is initialised for
+        *  encryption, if false for decryption.
+        * @param param the key and other data required by the cipher.
+        * @exception ArgumentException if the parameters argument is
+        * inappropriate.
+        */
         public void Init(bool forEncryption, ICipherParameters parameters)
         {
             bool oldEncrypting = this.encrypting;
@@ -76,35 +82,32 @@ public void Init(bool forEncryption, ICipherParameters parameters)
             }
         }
 
-        /// <summary>
-        /// Return the algorithm name and mode (e.g., "AES/CBC").
-        /// </summary>
+		/**
+        * return the algorithm name and mode.
+        *
+        * @return the name of the underlying algorithm followed by "/CBC".
+        */
         public string AlgorithmName
         {
             get { return cipher.AlgorithmName + "/CBC"; }
         }
 
-        /// <summary>Indicates whether this cipher can handle partial blocks.</summary>
+		public bool IsPartialBlockOkay
 		{
 			get { return false; }
 		}
 
-        /// <summary>
-        /// Return the block size of the underlying cipher.
-        /// </summary>
-        /// <returns>The block size in bytes.</returns>
+		/**
+        * return the block size of the underlying cipher.
+        *
+        * @return the block size of the underlying cipher.
+        */
         public int GetBlockSize()
         {
             return cipher.GetBlockSize();
         }
 
-        /// <summary>Process a single block of data.</summary>
-        /// <param name="input">The input buffer containing the data to be processed.</param>
-        /// <param name="inOff">The offset into the input buffer.</param>
-        /// <param name="output">The output buffer to write the processed data to.</param>
-        /// <param name="outOff">The offset into the output buffer.</param>
-        /// <returns>The number of bytes processed and produced.</returns>
-        /// <exception cref="DataLengthException">If input block is wrong size, or output buffer too small.</exception>
+        public int ProcessBlock(byte[] input, int inOff, byte[] output, int outOff)
         {
 #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
             return encrypting
@@ -118,21 +121,18 @@ public int GetBlockSize()
         }
 
 #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-        /// <summary>Process a single block of data using Spans.</summary>
-        /// <param name="input">The input span containing the data to be processed.</param>
-        /// <param name="output">The output span to write the processed data to.</param>
-        /// <returns>The number of bytes processed and produced.</returns>
-        /// <exception cref="DataLengthException">If input span is wrong size, or output span too small.</exception>
+        public int ProcessBlock(ReadOnlySpan<byte> input, Span<byte> output)
         {
             return encrypting
                 ? EncryptBlock(input, output)
                 : DecryptBlock(input, output);
         }
 #endif
 
-        /// <summary>
-        /// Reset the chaining vector back to the IV and reset the underlying cipher.
-        /// </summary>
+        /**
+        * reset the chaining vector back to the IV and reset the underlying
+        * cipher.
+        */
         public void Reset()
         {
             Array.Copy(IV, 0, cbcV, 0, IV.Length);
diff --git a/crypto/src/crypto/modes/IAeadCipher.cs b/crypto/src/crypto/modes/IAeadCipher.cs
@@ -61,6 +61,7 @@ public interface IAeadCipher
         /// <param name="input">The byte to be processed.</param>
         /// <param name="output">The output span.</param>
         /// <returns>The number of bytes written to the output span.</returns>
+        int ProcessByte(byte input, Span<byte> output);
 #endif
 
         /// <summary>Process a sequence of bytes from the input buffer.</summary>
@@ -78,6 +79,7 @@ public interface IAeadCipher
         /// <param name="input">The input span.</param>
         /// <param name="output">The output span.</param>
         /// <returns>The number of bytes written to the output span.</returns>
+        int ProcessBytes(ReadOnlySpan<byte> input, Span<byte> output);
 #endif
 
         /// <summary>Finish the operation, generating or verifying the MAC.</summary>
@@ -93,6 +95,7 @@ public interface IAeadCipher
         /// <param name="output">The output span for remaining data and/or MAC.</param>
         /// <returns>Number of bytes written to the output span.</returns>
         /// <exception cref="InvalidCipherTextException">If the MAC check fails.</exception>
+        int DoFinal(Span<byte> output);
 #endif
 
         /// <summary>Return the Message Authentication Code (MAC) generated or verified by the cipher.</summary>
