public void Init(
            bool				forWrapping,
            ICipherParameters	parameters)
        {
            this.forWrapping = forWrapping;

            if (parameters is ParametersWithRandom)
            {
                parameters = ((ParametersWithRandom) parameters).Parameters;
            }

            if (parameters is KeyParameter)
            {
                this.param = (KeyParameter) parameters;
            }
            else if (parameters is ParametersWithIV)
            {
                ParametersWithIV pIV = (ParametersWithIV) parameters;
                byte[] iv = pIV.GetIV();

                if (iv.Length != 8)
                    throw new ArgumentException("IV length not equal to 8", "parameters");

                this.iv = iv;
                this.param = (KeyParameter) pIV.Parameters;
            }
            else
            {
                // TODO Throw an exception for bad parameters?
            }
        }
 /**
  * Base constructor.
  *
  * @param key key to be used by underlying cipher
  * @param macSize macSize in bits
  * @param nonce nonce to be used
  * @param associatedText associated text, if any
  */
 public CcmParameters(
     KeyParameter	key,
     int				macSize,
     byte[]			nonce,
     byte[]			associatedText)
     : base(key, macSize, nonce, associatedText)
 {
 }
 /**
  * Base constructor.
  *
  * @param key key to be used by underlying cipher
  * @param macSize macSize in bits
  * @param nonce nonce to be used
  * @param associatedText associated text, if any
  */
 public AeadParameters(
     KeyParameter	key,
     int				macSize,
     byte[]			nonce,
     byte[]			associatedText)
 {
     this.key = key;
     this.nonce = nonce;
     this.macSize = macSize;
     this.associatedText = associatedText;
 }
 /**
  * Base constructor.
  *
  * @param key key to be used by underlying cipher
  * @param macSize macSize in bits
  * @param nonce nonce to be used
  */
 public AeadParameters(KeyParameter key, int macSize, byte[] nonce)
     : this(key, macSize, nonce, null)
 {
 }
        public void Init(
            ICipherParameters parameters)
        {
            Reset();

            if (!(parameters is KeyParameter || parameters is ParametersWithIV))
                throw new ArgumentException("parameters must be an instance of KeyParameter or ParametersWithIV");

            // KeyParameter must contain a double or triple length DES key,
            // however the underlying cipher is a single DES. The middle and
            // right key are used only in the final step.

            KeyParameter kp;
            if (parameters is KeyParameter)
            {
                kp = (KeyParameter)parameters;
            }
            else
            {
                kp = (KeyParameter)((ParametersWithIV)parameters).Parameters;
            }

            KeyParameter key1;
            byte[] keyvalue = kp.GetKey();

            if (keyvalue.Length == 16)
            { // Double length DES key
                key1 = new KeyParameter(keyvalue, 0, 8);
                this.lastKey2 = new KeyParameter(keyvalue, 8, 8);
                this.lastKey3 = key1;
            }
            else if (keyvalue.Length == 24)
            { // Triple length DES key
                key1 = new KeyParameter(keyvalue, 0, 8);
                this.lastKey2 = new KeyParameter(keyvalue, 8, 8);
                this.lastKey3 = new KeyParameter(keyvalue, 16, 8);
            }
            else
            {
                throw new ArgumentException("Key must be either 112 or 168 bit long");
            }

            if (parameters is ParametersWithIV)
            {
                cipher.Init(true, new ParametersWithIV(key1, ((ParametersWithIV)parameters).GetIV()));
            }
            else
            {
                cipher.Init(true, key1);
            }
        }
        private byte[] EncryptBlock(
            byte[]  input,
            int     inOff,
            int     inLen,
            byte[]  z)
        {
            byte[]          C = null;
            KeyParameter    macKey = null;
            KdfParameters   kParam = new KdfParameters(z, param.GetDerivationV());
            int             c_text_length = 0;
            int             macKeySize = param.MacKeySize;

            if (cipher == null)     // stream mode
            {
                byte[] Buffer = GenerateKdfBytes(kParam, inLen + (macKeySize / 8));

                C = new byte[inLen + mac.GetMacSize()];
                c_text_length = inLen;

                for (int i = 0; i != inLen; i++)
                {
                    C[i] = (byte)(input[inOff + i] ^ Buffer[i]);
                }

                macKey = new KeyParameter(Buffer, inLen, (macKeySize / 8));
            }
            else
            {
                int cipherKeySize = ((IesWithCipherParameters)param).CipherKeySize;
                byte[] Buffer = GenerateKdfBytes(kParam, (cipherKeySize / 8) + (macKeySize / 8));

                cipher.Init(true, new KeyParameter(Buffer, 0, (cipherKeySize / 8)));

                c_text_length = cipher.GetOutputSize(inLen);
                byte[] tmp = new byte[c_text_length];

                int len = cipher.ProcessBytes(input, inOff, inLen, tmp, 0);
                len += cipher.DoFinal(tmp, len);

                C = new byte[len + mac.GetMacSize()];
                c_text_length = len;

                Array.Copy(tmp, 0, C, 0, len);

                macKey = new KeyParameter(Buffer, (cipherKeySize / 8), (macKeySize / 8));
            }

            byte[] macIV = param.GetEncodingV();

            mac.Init(macKey);
            mac.BlockUpdate(C, 0, c_text_length);
            mac.BlockUpdate(macIV, 0, macIV.Length);
            //
            // return the message and it's MAC
            //
            mac.DoFinal(C, c_text_length);
            return C;
        }
        private byte[] DecryptBlock(
            byte[]  in_enc,
            int     inOff,
            int     inLen,
            byte[]  z)
        {
            byte[]          M = null;
            KeyParameter    macKey = null;
            KdfParameters   kParam = new KdfParameters(z, param.GetDerivationV());
            int             macKeySize = param.MacKeySize;

            kdf.Init(kParam);

            inLen -= mac.GetMacSize();

            if (cipher == null)     // stream mode
            {
                byte[] Buffer = GenerateKdfBytes(kParam, inLen + (macKeySize / 8));

                M = new byte[inLen];

                for (int i = 0; i != inLen; i++)
                {
                    M[i] = (byte)(in_enc[inOff + i] ^ Buffer[i]);
                }

                macKey = new KeyParameter(Buffer, inLen, (macKeySize / 8));
            }
            else
            {
                int cipherKeySize = ((IesWithCipherParameters)param).CipherKeySize;
                byte[] Buffer = GenerateKdfBytes(kParam, (cipherKeySize / 8) + (macKeySize / 8));

                cipher.Init(false, new KeyParameter(Buffer, 0, (cipherKeySize / 8)));

                M = cipher.DoFinal(in_enc, inOff, inLen);

                macKey = new KeyParameter(Buffer, (cipherKeySize / 8), (macKeySize / 8));
            }

            byte[] macIV = param.GetEncodingV();

            mac.Init(macKey);
            mac.BlockUpdate(in_enc, inOff, inLen);
            mac.BlockUpdate(macIV, 0, macIV.Length);
            mac.DoFinal(macBuf, 0);

            inOff += inLen;

            byte[] T1 = Arrays.CopyOfRange(in_enc, inOff, inOff + macBuf.Length);

            if (!Arrays.ConstantTimeAreEqual(T1, macBuf))
                throw (new InvalidCipherTextException("Invalid MAC."));

            return M;
        }
 public TweakableBlockCipherParameters(KeyParameter key, byte[] tweak)
 {
     this.key = key;
     this.tweak = Arrays.Clone(tweak);
 }
        /**
        * Method init
        *
        * @param forWrapping
        * @param param
        */
        public void Init(
            bool				forWrapping,
            ICipherParameters	parameters)
        {
            this.forWrapping = forWrapping;
            this.engine = new CbcBlockCipher(new DesEdeEngine());

            SecureRandom sr;
            if (parameters is ParametersWithRandom)
            {
                ParametersWithRandom pr = (ParametersWithRandom) parameters;
                parameters = pr.Parameters;
                sr = pr.Random;
            }
            else
            {
                sr = new SecureRandom();
            }

            if (parameters is KeyParameter)
            {
                this.param = (KeyParameter) parameters;
                if (this.forWrapping)
                {
                    // Hm, we have no IV but we want to wrap ?!?
                    // well, then we have to create our own IV.
                    this.iv = new byte[8];
                    sr.NextBytes(iv);

                    this.paramPlusIV = new ParametersWithIV(this.param, this.iv);
                }
            }
            else if (parameters is ParametersWithIV)
            {
                if (!forWrapping)
                    throw new ArgumentException("You should not supply an IV for unwrapping");

                this.paramPlusIV = (ParametersWithIV) parameters;
                this.iv = this.paramPlusIV.GetIV();
                this.param = (KeyParameter) this.paramPlusIV.Parameters;

                if (this.iv.Length != 8)
                    throw new ArgumentException("IV is not 8 octets", "parameters");
            }
        }
        private byte[] GenerateDerivedKey(
            int dkLen)
        {
            int     hLen = hMac.GetMacSize();
            int     l = (dkLen + hLen - 1) / hLen;
            byte[]  iBuf = new byte[4];
            byte[]  outBytes = new byte[l * hLen];
            int     outPos = 0;

            ICipherParameters param = new KeyParameter(mPassword);

            hMac.Init(param);

            for (int i = 1; i <= l; i++)
            {
                // Increment the value in 'iBuf'
                int pos = 3;
                while (++iBuf[pos] == 0)
                {
                    --pos;
                }

                F(mSalt, mIterationCount, iBuf, outBytes, outPos);
                outPos += hLen;
            }

            return outBytes;
        }