package org.bouncycastle.crypto.modes;

import org.bouncycastle.crypto.BlockCipher;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.DataLengthException;
import org.bouncycastle.crypto.params.ParametersWithIV;

/**
 * Implements the Segmented Integer Counter (SIC) mode on top of a simple
 * block cipher. This mode is also known as CTR mode.
 */
public class SICBlockCipher implements BlockCipher
{
  private BlockCipher     cipher = null;
  private int             blockSize;
  private byte[]          IV;
  private byte[]          counter;
  private byte[]          counterOut;
  private boolean         encrypting;


  /**
   * Basic constructor.
   *
   * @param c the block cipher to be used.
   */
  public SICBlockCipher(BlockCipher c) {
    this.cipher = c;
    this.blockSize = cipher.getBlockSize();
    this.IV = new byte[blockSize];
    this.counter = new byte[blockSize];
    this.counterOut = new byte[blockSize];
  }


  /**
   * return the underlying block cipher that we are wrapping.
   *
   * @return the underlying block cipher that we are wrapping.
   */
  public BlockCipher getUnderlyingCipher() {
    return cipher;
  }


  public void init(boolean forEncryption, CipherParameters params)
      throws IllegalArgumentException {
    this.encrypting = forEncryption;

    if (params instanceof ParametersWithIV) {
      ParametersWithIV ivParam = (ParametersWithIV)params;
      byte[]           iv      = ivParam.getIV();
      System.arraycopy(iv, 0, IV, 0, IV.length);

      reset();
      cipher.init(true, ivParam.getParameters());
    }
  }


  public String getAlgorithmName() {
    return cipher.getAlgorithmName() + "/SIC";
  }


  public int getBlockSize() {
    return cipher.getBlockSize();
  }


  public int processBlock(byte[] in, int inOff, byte[] out, int outOff)
      throws DataLengthException, IllegalStateException {
    cipher.processBlock(counter, 0, counterOut, 0);

    //
    // XOR the counterOut with the plaintext producing the cipher text
    //
    for (int i = 0; i < counterOut.length; i++) {
      out[outOff + i] = (byte)(counterOut[i] ^ in[inOff + i]);
    }

	int	carry = 1;
	
	for (int i = counter.length - 1; i >= 0; i--)
	{
		int	x = (counter[i] & 0xff) + carry;
		
		if (x > 0xff)
		{
			carry = 1;
		}
		else
		{
			carry = 0;
		}
		
		counter[i] = (byte)x;
	}

    return counter.length;
  }


  public void reset() {
    System.arraycopy(IV, 0, counter, 0, counter.length);
    cipher.reset();
  }
}
