BufferedAsymmetricBlockCipher.cs :  » PDF » iTextSharp » Org » BouncyCastle » Crypto » C# / CSharp Open Source

using System;
using System.Diagnostics;

using Org.BouncyCastle.Crypto.Engines;

namespace Org.BouncyCastle.Crypto{
    /**
    * a buffer wrapper for an asymmetric block cipher, allowing input
    * to be accumulated in a piecemeal fashion until final processing.
    */
    public class BufferedAsymmetricBlockCipher
    : BufferedCipherBase
    {
    private readonly IAsymmetricBlockCipher cipher;

    private byte[] buffer;
    private int bufOff;

    /**
        * base constructor.
        *
        * @param cipher the cipher this buffering object wraps.
        */
        public BufferedAsymmetricBlockCipher(
            IAsymmetricBlockCipher cipher)
        {
            this.cipher = cipher;
    }

    /**
        * return the amount of data sitting in the buffer.
        *
        * @return the amount of data sitting in the buffer.
        */
        internal int GetBufferPosition()
        {
            return bufOff;
        }

    public override string AlgorithmName
        {
            get { return cipher.AlgorithmName; }
        }

    public override int GetBlockSize()
        {
      return cipher.GetInputBlockSize();
        }

    public override int GetOutputSize(
      int length)
    {
      return cipher.GetOutputBlockSize();
    }

    public override int GetUpdateOutputSize(
      int length)
    {
      return 0;
    }

    /**
        * initialise the buffer and the underlying cipher.
        *
        * @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.
        */
        public override void Init(
            bool        forEncryption,
            ICipherParameters  parameters)
        {
      Reset();

      cipher.Init(forEncryption, parameters);

      //
      // we allow for an extra byte where people are using their own padding
      // mechanisms on a raw cipher.
      //
      this.buffer = new byte[cipher.GetInputBlockSize() + (forEncryption ? 1 : 0)];
      this.bufOff = 0;
        }

    public override byte[] ProcessByte(
      byte input)
    {
      if (bufOff >= buffer.Length)
        throw new DataLengthException("attempt to process message to long for cipher");

      buffer[bufOff++] = input;
      return null;
    }

    public override byte[] ProcessBytes(
      byte[]  input,
      int    inOff,
      int    length)
    {
      if (length < 1)
        return null;

      if (input == null)
        throw new ArgumentNullException("input");
      if (bufOff + length > buffer.Length)
        throw new DataLengthException("attempt to process message to long for cipher");

      Array.Copy(input, inOff, buffer, bufOff, length);
      bufOff += length;
      return null;
    }

    /**
        * process the contents of the buffer using the underlying
        * cipher.
        *
        * @return the result of the encryption/decryption process on the
        * buffer.
        * @exception InvalidCipherTextException if we are given a garbage block.
        */
        public override byte[] DoFinal()
        {
      byte[] outBytes = bufOff > 0
        ?  cipher.ProcessBlock(buffer, 0, bufOff)
        :  EmptyBuffer;

      Reset();

      return outBytes;
        }

    public override byte[] DoFinal(
      byte[]  input,
      int    inOff,
      int    length)
    {
      ProcessBytes(input, inOff, length);
      return DoFinal();
    }

    /// <summary>Reset the buffer</summary>
        public override void Reset()
        {
      if (buffer != null)
      {
        Array.Clear(buffer, 0, buffer.Length);
        bufOff = 0;
      }
        }
    }
}