/**
 * set up for use in conjunction with a block cipher to handle the
 * message.
 *
 * @param agree the key agreement used as the basis for the encryption
 * @param kdf the key derivation function used for byte generation
 * @param mac the message authentication code generator for the message
 * @param cipher the cipher to used for encrypting the message
 */
 public IesEngine(IBasicAgreement agree, IDerivationFunction kdf, IMac mac, BufferedBlockCipher cipher)
 {
     _agree = agree;
     _kdf = kdf;
     _mac = mac;
     _macBuf = new byte[mac.GetMacSize()];
     _cipher = cipher;
 }
Exemplo n.º 2
0
    public AesStream(byte[] data, byte[] key) : base(data)
    {
        EncryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesEngine(), 8));
        EncryptCipher.Init(true, new ParametersWithIV(new KeyParameter(key), key, 0, 16));

        DecryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesEngine(), 8));
        DecryptCipher.Init(false, new ParametersWithIV(new KeyParameter(key), key, 0, 16));

        var oldStream = this.BaseStream;

        this.BaseStream = new CipherStream(oldStream, DecryptCipher, EncryptCipher);
    }
Exemplo n.º 3
0
        /// <summary>
        /// Encrypt data with DES-CBC
        /// </summary>
        /// <param name="data">Data to encrypt</param>
        /// <param name="key">Key</param>
        /// <param name="iv">IV</param>
        /// <returns>Encrypted data</returns>
        public static byte[] EncryptCBC(byte[] data, byte[] key, byte[] iv)
        {
            byte[] enc = new byte[data.Length];

            IBufferedCipher  cipher     = new BufferedBlockCipher(new CbcBlockCipher(new DesEngine()));
            ParametersWithIV parameters = new ParametersWithIV(new KeyParameter(key, 0, key.Length), iv, 0, iv.Length);

            cipher.Init(true, parameters);
            cipher.ProcessBytes(data, enc, 0);

            return(enc);
        }
Exemplo n.º 4
0
        public void InitEncryption(byte[] key, bool write)
        {
            EncryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesEngine(), 8));
            EncryptCipher.Init(true, new ParametersWithIV(
                                   new KeyParameter(key), key, 0, 16));

            DecryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesEngine(), 8));
            DecryptCipher.Init(false, new ParametersWithIV(
                                   new KeyParameter(key), key, 0, 16));

            BaseStream = new CipherStream(BaseStream, DecryptCipher, EncryptCipher);
        }
Exemplo n.º 5
0
 /**
  * set up for use in conjunction with a block cipher to handle the
  * message.
  *
  * @param agree the key agreement used as the basis for the encryption
  * @param kdf the key derivation function used for byte generation
  * @param mac the message authentication code generator for the message
  * @param cipher the cipher to used for encrypting the message
  */
 public IesEngine(
     IBasicAgreement agree,
     IDerivationFunction kdf,
     IMac mac,
     BufferedBlockCipher cipher)
 {
     this.agree  = agree;
     this.kdf    = kdf;
     this.mac    = mac;
     this.macBuf = new byte[mac.GetMacSize()];
     this.cipher = cipher;
 }
Exemplo n.º 6
0
        public AesCbcCryptor(byte[] key, byte[] iv)
        {
            KeyParameter keyParam = new KeyParameter(key);

            this._parametersWithIv = new ParametersWithIV(keyParam, iv, 0, iv.Length);
            AesEngine           engine      = new AesEngine();
            CbcBlockCipher      blockCipher = new CbcBlockCipher(engine);
            IBlockCipherPadding padding     = new Pkcs7Padding();

            this._cipher = new BufferedBlockCipher(blockCipher);
            this._cipher.Init(false, this._parametersWithIv);
        }
Exemplo n.º 7
0
        public byte[] DecryptDES3(byte[] message, byte[] key)
        {
            DesEdeEngine        desedeEngine   = new DesEdeEngine();
            BufferedBlockCipher bufferedCipher = new BufferedBlockCipher(desedeEngine);

            // Create the KeyParameter for the DES3 key generated.
            KeyParameter keyparam = ParameterUtilities.CreateKeyParameter("DESEDE", key);

            byte[] output = new byte[bufferedCipher.GetOutputSize(message.Length)];
            bufferedCipher.Init(false, keyparam);
            output = bufferedCipher.DoFinal(message);
            return(output);
        }
Exemplo n.º 8
0
        /// <summary>
        /// De/encrypt data via AES128-CBC without applying standarized
        /// padding (SmartGlass uses out-of-spec padding technique).
        /// </summary>
        /// <returns>The transformed data without padding.</returns>
        /// <param name="data">Data to transform.</param>
        /// <param name="initVector">Init vector.</param>
        /// <param name="encrypt">If set to <c>true</c> data is encrypted, <c>false</c> decrypts.</param>
        private byte[] UseAesCipherWithoutPadding(byte[] data, byte[] initVector, bool encrypt)
        {
            var aesCipher   = new AesEngine();
            var blockCipher = new CbcBlockCipher(aesCipher);
            var cipher      = new BufferedBlockCipher(blockCipher);

            var keyParams    = new KeyParameter(_cryptoKey);
            var paramsWithIv = new ParametersWithIV(keyParams, initVector);

            cipher.Init(encrypt, paramsWithIv);

            return(cipher.DoFinal(data));
        }
Exemplo n.º 9
0
 private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, byte[] key, byte[] iv)
 {
     try
     {
         this.mode.Init(forEncrypt, new ParametersWithIV(new KeyParameter(key), iv));
         BufferedBlockCipher cipher = new BufferedBlockCipher(this.mode);
         return(cipher.DoFinal(input));
     }
     catch (CryptoException)
     {
         throw;
     }
 }
Exemplo n.º 10
0
 private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, byte[] key)
 {
     try
     {
         this.cipher = new BufferedBlockCipher(this.blockCipher);
         this.cipher.Init(forEncrypt, new KeyParameter(key));
         return(this.cipher.DoFinal(input));
     }
     catch (CryptoException)
     {
         throw;
     }
 }
Exemplo n.º 11
0
 /**
  * set up for use with stream mode, where the key derivation function
  * is used to provide a stream of bytes to xor with the message.
  *  @param agree the key agreement used as the basis for the encryption
  * @param kdf    the key derivation function used for byte generation
  * @param mac    the message authentication code generator for the message
  * @param hash   hash ing function
  * @param cipher the actual cipher
  */
 public EthereumIesEngine(
     IBasicAgreement agreement,
     IDerivationFunction kdf,
     IMac mac,
     IDigest hash,
     BufferedBlockCipher cipher)
 {
     _agreement = agreement;
     _kdf       = kdf;
     Mac        = mac;
     _hash      = hash;
     _macBuf    = new byte[mac.GetMacSize()];
     Cipher     = cipher;
 }
Exemplo n.º 12
0
        //private
        private static byte[] encryptDecrypt(byte[] input, byte[] key, byte[] iv, BlockMode mode, BlockPadding padding, bool encrypt)
        {
            DesEdeEngine        engine = new DesEdeEngine();
            IBlockCipher        cipherMode;
            BufferedBlockCipher cipher;
            KeyParameter        keyP      = new KeyParameter(key);
            ParametersWithIV    keyParams = new ParametersWithIV(keyP, iv);

            if (mode == BlockMode.CBC)
            {
                cipherMode = new CbcBlockCipher(engine);
            }
            else if (mode == BlockMode.CFB)
            {
                cipherMode = new CfbBlockCipher(engine, iv.Length);
            }
            else if (mode == BlockMode.OFB)
            {
                cipherMode = new OfbBlockCipher(engine, iv.Length);
            }
            else
            {
                throw new Exception("mode must be a valid BlockMode.");
            }

            if (padding == BlockPadding.PKCS7Padding)
            {
                cipher = new PaddedBufferedBlockCipher(cipherMode, new Pkcs7Padding());
            }
            else if (padding == BlockPadding.ZeroBytePadding)
            {
                cipher = new PaddedBufferedBlockCipher(cipherMode, new ZeroBytePadding());
            }
            else if (padding == BlockPadding.NoPadding)
            {
                cipher = new BufferedBlockCipher(cipherMode);
            }
            else
            {
                throw new Exception("padding must be a valid BlockPadding.");
            }

            cipher.Init(encrypt, keyParams);
            byte[] output = new byte[cipher.GetOutputSize(input.Length)];
            int    length = cipher.ProcessBytes(input, output, 0);

            cipher.DoFinal(output, length);

            return(output);
        }
Exemplo n.º 13
0
            internal PbeTest(
                Pkcs5Test			enclosingInstance,
                int					id,
                BufferedBlockCipher	cipher,
                byte[]				sample,
                int					keySize)
            {
                InitBlock(enclosingInstance);

                this.id = id;
                this.cipher = cipher;
                this.sample = sample;
                this.keySize = keySize;
            }
Exemplo n.º 14
0
        public byte[] Decrypt(byte[] key, byte[] iv, byte[] data)
        {
            //BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(engine, new ISO7816d4Padding());
            BufferedBlockCipher cipher = new BufferedBlockCipher(engine);

            //cipher.Init(false, new ParametersWithIV(new DesParameters(key), iv));
            cipher.Init(false, new DesEdeParameters(key));
            byte[] rv  = new byte[cipher.GetOutputSize(data.Length)];
            int    tam = cipher.ProcessBytes(data, 0, data.Length, rv, 0);

            cipher.DoFinal(rv, tam);

            return(rv);
        }
Exemplo n.º 15
0
            internal PbeTest(
                Pkcs5Test enclosingInstance,
                int id,
                BufferedBlockCipher cipher,
                byte[]                          sample,
                int keySize)
            {
                InitBlock(enclosingInstance);

                this.id      = id;
                this.cipher  = cipher;
                this.sample  = sample;
                this.keySize = keySize;
            }
Exemplo n.º 16
0
        public static EncryptedPrivateKeyInfo createEncryptedPrivateKeyInfo(
            String algorithm,
            char[] passPhrase,
            byte[] salt,
            int iterationCount,
            PrivateKeyInfo keyInfo)
        {
            if (!PBEUtil.isPBEAlgorithm(algorithm))
            {
                throw new Exception("attempt to use non-PBE algorithm with PBE EncryptedPrivateKeyInfo generation");
            }

            ASN1Encodable    parameters    = PBEUtil.generateAlgorithmParameters(algorithm, salt, iterationCount);
            CipherParameters keyParameters = PBEUtil.generateCipherParameters(algorithm, passPhrase, parameters);

            byte[] encoding = null;
            Object engine   = PBEUtil.createEngine(algorithm);

            if (engine is BufferedBlockCipher)
            {
                BufferedBlockCipher cipher = (BufferedBlockCipher)engine;

                cipher.init(true, keyParameters);

                byte[] keyBytes = keyInfo.getEncoded();

                int encLen = cipher.getOutputSize(keyBytes.Length);

                encoding = new byte[encLen];

                int off = cipher.processBytes(keyBytes, 0, keyBytes.Length, encoding, 0);

                cipher.doFinal(encoding, off);
            }
            else if (engine is StreamCipher)
            {
                StreamCipher cipher = (StreamCipher)engine;

                cipher.init(true, keyParameters);

                byte[] keyBytes = keyInfo.getEncoded();

                encoding = new byte[keyBytes.Length];

                cipher.processBytes(keyBytes, 0, keyBytes.Length, encoding, 0);
            }

            return(new EncryptedPrivateKeyInfo(new AlgorithmIdentifier(PBEUtil.getObjectIdentifier(algorithm), parameters), encoding));
        }
Exemplo n.º 17
0
        public Packet ChannelEncrypt(ICipherSetRemoteInfo channelInfo, Packet inner)
        {
            var ci = (CS1ARemoteInfo)channelInfo;

            // TODO:  Validate we don't care about endianess of IV here

            // Setup and encrypt the actual data
            byte[] aesIV = new byte[16];
            Buffer.BlockCopy(BitConverter.GetBytes(ci.IV), 0, aesIV, 0, 4);
            Array.Clear(aesIV, 4, 12);

            var cipher     = new SicBlockCipher(new AesFastEngine());
            var parameters = new ParametersWithIV(new KeyParameter(ci.EncryptionKey), aesIV);

            cipher.Init(true, parameters);

            var encryptedInner = new byte[inner.FullPacket.Length];
            BufferedBlockCipher bufferCipher = new BufferedBlockCipher(cipher);
            var offset = bufferCipher.ProcessBytes(inner.FullPacket, encryptedInner, 0);

            bufferCipher.DoFinal(encryptedInner, offset);

            // Hmac the output
            byte[] hmacKey = new byte[20];
            Buffer.BlockCopy(ci.EncryptionKey, 0, hmacKey, 0, 16);
            Buffer.BlockCopy(BitConverter.GetBytes(ci.IV), 0, hmacKey, 16, 4);

            var hmac = new HMac(new Sha256Digest());

            hmac.Init(new KeyParameter(hmacKey));
            hmac.BlockUpdate(encryptedInner, 0, encryptedInner.Length);
            byte[] mac = new byte[hmac.GetMacSize()];
            hmac.DoFinal(mac, 0);
            var foldedMac = Helpers.Fold(mac, 3);

            // Create the outgoing packet
            Packet outPacket = new Packet();

            outPacket.Body = new byte[encryptedInner.Length + 24];
            Buffer.BlockCopy(ci.Token, 0, outPacket.Body, 0, 16);
            Buffer.BlockCopy(BitConverter.GetBytes(ci.IV), 0, outPacket.Body, 16, 4);
            Buffer.BlockCopy(encryptedInner, 0, outPacket.Body, 20, encryptedInner.Length);
            Buffer.BlockCopy(foldedMac, 0, outPacket.Body, outPacket.Body.Length - 4, 4);

            // Next IV next packet
            ++ci.IV;

            return(outPacket);
        }
Exemplo n.º 18
0
        } //private byte[] encryptDesEde(byte[] plain)

        private byte[] encryptAES(byte[] plain, KeyChaining chaining = KeyChaining.CBC, bool doEncrypt = true, byte[] icv = null)
        {
            BufferedBlockCipher cipher = chaining == KeyChaining.CBC
                ? new BufferedBlockCipher(new CbcBlockCipher(new AesEngine()))   //CBC chaining
                : new BufferedBlockCipher(new AesEngine());                      //ECB chaining

            if (icv != null)
            {
                cipher.Init(doEncrypt, new ParametersWithIV(new KeyParameter(theKey), icv));
            }
            else
            {
                cipher.Init(doEncrypt, new KeyParameter(theKey));
            }

            MemoryStream dst = new MemoryStream();

            byte[] bin    = padded(plain, 24);
            byte[] result = new byte[bin.Length];

            int outL = cipher.ProcessBytes(bin, result, 0);

            if (outL > 0)
            {
                dst.Write(result, 0, outL);
            }

            if (outL < plain.Length)
            {
                outL = cipher.DoFinal(result, 0);
                if (outL > 0)
                {
                    dst.Write(result, 0, outL);
                }
            } //if (outL < plain.Length)

            dst.Position = 0;
            result       = dst.ToArray();
            dst.Close();

            if (result.Length > plain.Length)
            {
                byte[] res = new byte[plain.Length];
                System.Array.Copy(result, res, plain.Length);
                return(res);
            } //if (result.Length > plain.Length)

            return(result);
        } //private byte[] encryptAES(byte[] plain)
Exemplo n.º 19
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static byte[] ComputeCbc3Des(this byte[] data, KeyParameter key)
        {
            IBlockCipher engine = new DesEdeEngine();
            var          cipher = new BufferedBlockCipher(new CbcBlockCipher(engine));

            cipher.Init(true, key);

            var cbc = new byte[cipher.GetOutputSize(data.Length)];

            var length = cipher.ProcessBytes(data, 0, data.Length, cbc, 0);

            cipher.DoFinal(cbc, length);

            return(cbc);
        }
Exemplo n.º 20
0
        public KGcmBlockCipher(IBlockCipher cipher)
        {
            this.cipher    = cipher;
            this.ctrCipher = new BufferedBlockCipher(new KCtrBlockCipher(this.cipher));
            this.macSize   = 0;

            this.IV   = new byte[cipher.GetBlockSize()];
            this.H    = new byte[cipher.GetBlockSize()];
            this.b    = new byte[cipher.GetBlockSize()];
            this.temp = new byte[cipher.GetBlockSize()];


            this.lambda_c = 0;
            this.lambda_o = 0;
        }
Exemplo n.º 21
0
        /// <summary>
        /// Creates a symmetric encryptor/decryptor object using the specified key and initialization vector (IV).
        /// </summary>
        /// <param name="forEncryption">Flag used to determine what object, a symmetric encryptor or a symmetric decryptor method returns.</param>
        /// <returns>A symmetric encryptor/decryptor object.</returns>
        public IBufferedCipher CreateTwofishCipher(bool forEncryption)
        {
            IBufferedCipher  cipher;
            var              keyParameter = new KeyParameter(Key);
            ParametersWithIV keyWithIv    = null;

            if (!ModeSignature.Equals("ECB"))
            {
                keyWithIv = new ParametersWithIV(keyParameter, IV);
            }

            switch (ModeSignature)
            {
            case "ECB":
            {
                cipher = new PaddedBufferedBlockCipher(new TwofishEngine());
                cipher.Init(forEncryption, keyParameter);
                return(cipher);
            }

            case "CBC":
            {
                cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new TwofishEngine()));
                cipher.Init(forEncryption, keyWithIv);
                return(cipher);
            }

            case "CFB":
            {
                cipher = new BufferedBlockCipher(new CfbBlockCipher(new TwofishEngine(), 16));
                cipher.Init(forEncryption, keyWithIv);
                return(cipher);
            }

            case "OFB":
            {
                cipher = new BufferedBlockCipher(new OfbBlockCipher(new TwofishEngine(), 16));
                cipher.Init(forEncryption, keyWithIv);
                return(cipher);
            }

            default:
            {
                throw new CryptographicException("Unknown block cipher mode '" + ModeSignature + "' used.");
            }
            }
        }
Exemplo n.º 22
0
        /// <summary>
        /// Encrypt stream with Blowfish-CBC
        /// </summary>
        /// <param name="input">Input stream to encrypt</param>
        /// <param name="output">Output stream</param>
        /// <param name="key">Key</param>
        /// <param name="iv">IV</param>
        /// <param name="paddingStyle">Padding</param>
        /// <param name="notifyProgression">Notify progression method</param>
        /// <param name="bufferSize">Buffer size</param>
        public static void EncryptCBC(Stream input, Stream output, byte[] key, byte[] iv, PaddingStyle paddingStyle = PaddingStyle.Pkcs7, Action <int> notifyProgression = null, int bufferSize = 4096)
        {
            IBufferedCipher  cipher     = new BufferedBlockCipher(new CbcBlockCipher(new BlowfishEngine()));
            ParametersWithIV parameters = new ParametersWithIV(new KeyParameter(key, 0, key.Length), iv, 0, iv.Length);

            cipher.Init(true, parameters);

            bool padDone = false;
            int  bytesRead;

            byte[] buffer = new byte[bufferSize];
            byte[] enc    = new byte[bufferSize];

            do
            {
                bytesRead = input.Read(buffer, 0, bufferSize);

                if (bytesRead == bufferSize)
                {
                    cipher.ProcessBytes(buffer, enc, 0);
                    output.Write(enc, 0, bytesRead);
                }
                else if (bytesRead > 0)
                {
                    byte[] smallBuffer = new byte[bytesRead];
                    Array.Copy(buffer, 0, smallBuffer, 0, bytesRead);
                    byte[] padData = Padding.Pad(smallBuffer, BLOCK_SIZE, paddingStyle);
                    cipher.ProcessBytes(padData, enc, 0);
                    output.Write(enc, 0, padData.Length);
                    padDone = true;
                }

                if (notifyProgression != null && bytesRead > 0)
                {
                    notifyProgression(bytesRead);
                }
            } while (bytesRead == bufferSize);

            if (!padDone)
            {
                buffer = new byte[0];
                byte[] padData = Padding.Pad(buffer, BLOCK_SIZE, paddingStyle);
                cipher.ProcessBytes(padData, enc, 0);
                output.Write(enc, 0, padData.Length);
            }
        }
Exemplo n.º 23
0
        private Byte[] Decrypt(BufferedBlockCipher cipher, Byte[] data)
        {
            var size      = cipher.GetOutputSize(data.Length);
            var outBuffer = new Byte[size];

            //int off1 = cipher.ProcessBytes(content, 0, content.Length, outBuffer, 0);
            cipher.DoFinal(data, 0, data.Length, outBuffer, 0);
            //int off2 = cipher.DoFinal(outBuffer, off1);
            //int resultSize = off1 + off2;
            var result = new Byte[outBuffer.Length /*resultSize*/];

            Array.Copy(outBuffer, 0, result, 0, result.Length);

            //String asString = Encoding.ASCII.GetString(result);
            //Console.WriteLine(asString);

            return(result);
        }
Exemplo n.º 24
0
        public static byte[] Encrypt(string key, byte[] inBytes)
        {
            var cipher = new BufferedBlockCipher(new BlowfishEngine());

            cipher.Init(true, new KeyParameter(Encoding.UTF8.GetBytes(key)));

            inBytes = BSwap(inBytes);

            var outBytes = new byte[cipher.GetOutputSize(inBytes.Length)];

            var len2 = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0);

            cipher.DoFinal(outBytes, len2);

            outBytes = BSwap(outBytes);

            return(outBytes);
        }
        public byte[] Decrypt(byte[] value)
        {
            BufferedBlockCipher aes    = new BufferedBlockCipher(new OfbBlockCipher(new AesEngine(), AesBlockSizeInBytes * 8));
            ArraySegment <byte> iv     = new ArraySegment <byte>(value, 0, AesBlockSizeInBytes);
            ArraySegment <byte> secret = new ArraySegment <byte>(value, AesBlockSizeInBytes, value.Length - AesBlockSizeInBytes);

            ParametersWithIV ivAndKey = new ParametersWithIV(new KeyParameter(aesKey), iv.ToArray());

            aes.Init(false, ivAndKey);

            int maximumSize = aes.GetOutputSize(secret.Count);

            byte[] outputBuffer = new byte[maximumSize];
            int    length1      = aes.ProcessBytes(secret.ToArray(), 0, secret.Count, outputBuffer, 0);
            int    length2      = aes.DoFinal(outputBuffer, length1);

            return(new ArraySegment <byte>(outputBuffer, 0, length1 + length2).ToArray());
        }
Exemplo n.º 26
0
        /*
         * No idea... doesnt work.. cant seem to fix it..
         *
         *
         */
        private static byte[] Transform(BufferedBlockCipher cipher, byte[] data)
        {
            var buf    = new byte[cipher.GetOutputSize(data.Length)];
            var length = cipher.ProcessBytes(data, 0, data.Length, buf, 0);

            try
            {
                length += cipher.DoFinal(buf, length);
            }
            catch (InvalidCipherTextException)
            {
                return(null);
            }
            var final = new byte[length];

            Array.Copy(buf, final, length);
            return(final);
        }
Exemplo n.º 27
0
        public AesStream(Stream stream, byte[] key)
        {
            BaseStream = stream;
            Key        = key;
#if MONO
            encryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
            encryptCipher.Init(true, new ParametersWithIV(
                                   new KeyParameter(key), key, 0, 16));
            decryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
            decryptCipher.Init(false, new ParametersWithIV(
                                   new KeyParameter(key), key, 0, 16));
#else
            var rijndael         = GenerateAES(key);
            var encryptTransform = rijndael.CreateEncryptor();
            var decryptTransform = rijndael.CreateDecryptor();
            encryptStream = new CryptoStream(BaseStream, encryptTransform, CryptoStreamMode.Write);
            decryptStream = new CryptoStream(BaseStream, decryptTransform, CryptoStreamMode.Read);
#endif
        }
Exemplo n.º 28
0
        public AESStream(Stream stream, byte[] key)

        {
            BaseStream = stream;

            Key = key;

            encryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));

            encryptCipher.Init(true, new ParametersWithIV(

                                   new KeyParameter(key), key, 0, 16));

            decryptCipher = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));

            decryptCipher.Init(false, new ParametersWithIV(

                                   new KeyParameter(key), key, 0, 16));
        }
Exemplo n.º 29
0
        public byte[] Encrypt(byte[] key, byte[] iv, byte[] data)
        {
            //BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(engine, new ISO7816d4Padding());
            //BufferedBlockCipher cipher = new BufferedGenericBlockCipher(cipher.getUnderlyingCipher(), new ISO7816d4Padding());
            BufferedBlockCipher cipher = new BufferedBlockCipher(engine);

            //cipher.Init(true, new ParametersWithIV(new DesParameters(key), iv));
            cipher.Init(true, new DesEdeParameters(key));
            byte[] rv  = new byte[cipher.GetOutputSize(data.Length)];
            int    tam = cipher.ProcessBytes(data, 0, data.Length, rv, 0);

            cipher.DoFinal(rv, tam);

            //BufferedBlockCipher bufferedCipher = new BufferedBlockCipher(desedeEngine);

            // Create the KeyParameter for the DES3 key generated.   KeyParameter keyparam = ParameterUtilities.CreateKeyParameter("DESEDE", keyDES3);  byte[] output = new byte[bufferedCipher.GetOutputSize(message.Length)];  bufferedCipher.Init(true, keyparam);  output = bufferedCipher.DoFinal(message);

            return(rv);
        }
Exemplo n.º 30
0
        public static PrivateKeyInfo createPrivateKeyInfo(
            char[] passPhrase,
            EncryptedPrivateKeyInfo encInfo)
        {
            CipherParameters keyParameters = PBEUtil.generateCipherParameters(encInfo.getEncryptionAlgorithm().getObjectId(), passPhrase, encInfo.getEncryptionAlgorithm().getParameters());
            Object           engine        = PBEUtil.createEngine(encInfo.getEncryptionAlgorithm().getObjectId());

            byte[] encoding = null;

            if (engine is BufferedBlockCipher)
            {
                BufferedBlockCipher cipher = (BufferedBlockCipher)engine;

                cipher.init(false, keyParameters);

                byte[] keyBytes = encInfo.getEncryptedData();

                int encLen = cipher.getOutputSize(keyBytes.Length);

                encoding = new byte[encLen];

                int off = cipher.processBytes(keyBytes, 0, keyBytes.Length, encoding, 0);

                cipher.doFinal(encoding, off);
            }
            else if (engine is StreamCipher)
            {
                StreamCipher cipher = (StreamCipher)engine;

                cipher.init(false, keyParameters);

                byte[] keyBytes = encInfo.getEncryptedData();

                encoding = new byte[keyBytes.Length];

                cipher.processBytes(keyBytes, 0, keyBytes.Length, encoding, 0);
            }

            ASN1InputStream aIn = new ASN1InputStream(new MemoryStream(encoding));

            return(PrivateKeyInfo.getInstance(aIn.readObject()));
        }
Exemplo n.º 31
0
        /// <summary>
        /// Creates a symmetric encryptor/decryptor object using the specified key and initialization vector (IV) for OFB block cipher mode of operation.
        /// </summary>
        /// <param name="forEncryption">Flag used to determine what object, a symmetric encryptor or a symmetric decryptor method returns.</param>
        /// <returns>A symmetric encryptor/decryptor object used for OFB block cipher mode of operation.</returns>
        public IBufferedCipher CreateTripleDesCipher(bool forEncryption)
        {
            IBufferedCipher cipher;
            var keyParameter = new KeyParameter(Key);
            var keyWithIv = new ParametersWithIV(keyParameter, IV);

            switch (ModeSignature)
            {
                case "OFB":
                {
                    cipher = new BufferedBlockCipher(new OfbBlockCipher(new DesEdeEngine(), 8)); // DesEdeEngine or Triple DES engine
                    cipher.Init(forEncryption, keyWithIv);
                    return cipher;
                }
                default:
                {
                    throw new CryptographicException("Unknown block cipher mode '" + ModeSignature + "' used.");
                }
            }
        }
Exemplo n.º 32
0
        private static byte[] DecryptAes(Stream inputStream, BufferedBlockCipher cipher, long length)
        {
            int blockSize    = cipher.GetBlockSize();
            int inputLength  = (int)length;
            int paddedLength = inputLength;

            if (paddedLength % blockSize > 0)
            {
                paddedLength += blockSize - paddedLength % blockSize;
            }

            byte[] input  = new byte[paddedLength];
            byte[] output = new byte[cipher.GetOutputSize(paddedLength)];

            inputStream.Read(input, 0, inputLength);
            int len = cipher.ProcessBytes(input, 0, input.Length, output, 0);

            cipher.DoFinal(output, len);
            return(output);
        }
Exemplo n.º 33
0
		public override void PerformTest()
		{
			base.PerformTest();

			//advanced tests with Gost28147KeyGenerator:
			//encrypt on hesh message; ECB mode:
			byte[] inBytes = Hex.Decode("4e6f77206973207468652074696d6520666f7220616c6c20");
			byte[] output = Hex.Decode("8ad3c8f56b27ff1fbd46409359bdc796bc350e71aac5f5c0");
			byte[] outBytes = new byte[inBytes.Length];

			byte[] key = generateKey(Hex.Decode("0123456789abcdef"));  //!!! heshing start_key - get 256 bits !!!
	//        System.out.println(new string(Hex.Encode(key)));
			ICipherParameters  param = new ParametersWithSBox(new KeyParameter(key), Gost28147Engine.GetSBox("E-A"));
			//CipherParameters  param = new Gost28147Parameters(key,"D-Test");
			BufferedBlockCipher cipher = new BufferedBlockCipher(new Gost28147Engine());

			cipher.Init(true, param);
			int len1 = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0);
			try
			{
				cipher.DoFinal(outBytes, len1);
			}
			catch (CryptoException e)
			{
				Fail("failed - exception " + e.ToString(), e);
			}

			if (outBytes.Length != output.Length)
			{
				Fail("failed - "
					+ "expected " + Hex.ToHexString(output) + " got "
					+ Hex.ToHexString(outBytes));
			}

			for (int i = 0; i != outBytes.Length; i++)
			{
				if (outBytes[i] != output[i])
				{
					Fail("failed - "
						+ "expected " + Hex.ToHexString(output)
						+ " got " + Hex.ToHexString(outBytes));
				}
			}


			//encrypt on hesh message; CFB mode:
			inBytes = Hex.Decode("bc350e71aac5f5c2");
			output = Hex.Decode("0ebbbafcf38f14a5");
			outBytes = new byte[inBytes.Length];

			key = generateKey(Hex.Decode("0123456789abcdef"));  //!!! heshing start_key - get 256 bits !!!
			param = new ParametersWithIV(
				new ParametersWithSBox(
					new KeyParameter(key), //key
					Gost28147Engine.GetSBox("E-A")), //type S-box
				Hex.Decode("1234567890abcdef")); //IV

			cipher = new BufferedBlockCipher(new CfbBlockCipher(new Gost28147Engine(), 64));

			cipher.Init(true, param);
			len1 = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0);
			try
			{
				cipher.DoFinal(outBytes, len1);
			}
			catch (CryptoException e)
			{
				Fail("failed - exception " + e.ToString(), e);
			}
			if (outBytes.Length != output.Length)
			{
				Fail("failed - "
					+ "expected " + Hex.ToHexString(output)
					+ " got " + Hex.ToHexString(outBytes));
			}
			for (int i = 0; i != outBytes.Length; i++)
			{
				if (outBytes[i] != output[i])
				{
					Fail("failed - "
						+ "expected " + Hex.ToHexString(output)
						+ " got " + Hex.ToHexString(outBytes));
				}
			}


			//encrypt on hesh message; CFB mode:
			inBytes = Hex.Decode("000102030405060708090a0b0c0d0e0fff0102030405060708090a0b0c0d0e0f");
			output = Hex.Decode("64988982819f0a1655e226e19ecad79d10cc73bac95c5d7da034786c12294225");
			outBytes = new byte[inBytes.Length];

			key = generateKey(Hex.Decode("aafd12f659cae63489b479e5076ddec2f06cb58faafd12f659cae63489b479e5"));  //!!! heshing start_key - get 256 bits !!!
			param = new ParametersWithIV(
				new ParametersWithSBox(
					new KeyParameter(key), //key
					Gost28147Engine.GetSBox("E-A")), //type S-box
				Hex.Decode("aafd12f659cae634")); //IV

			cipher = new BufferedBlockCipher(new CfbBlockCipher(new Gost28147Engine(), 64));

			cipher.Init(true, param);
			len1 = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0);

			cipher.DoFinal(outBytes, len1);

			if (outBytes.Length != output.Length)
			{
				Fail("failed - "
					+ "expected " + Hex.ToHexString(output)
					+ " got " + Hex.ToHexString(outBytes));
			}

			for (int i = 0; i != outBytes.Length; i++)
			{
				if (outBytes[i] != output[i])
				{
					Fail("failed - "
						+ "expected " + Hex.ToHexString(output)
						+ " got " + Hex.ToHexString(outBytes));
				}
			}

			//encrypt on hesh message; OFB mode:
			inBytes = Hex.Decode("bc350e71aa11345709acde");
			output = Hex.Decode("1bcc2282707c676fb656dc");
			outBytes = new byte[inBytes.Length];

			key = generateKey(Hex.Decode("0123456789abcdef"));  //!!! heshing start_key - get 256 bits !!!
			param = new ParametersWithIV(
				new ParametersWithSBox(
					new KeyParameter(key), //key
					Gost28147Engine.GetSBox("E-A")), //type S-box
				Hex.Decode("1234567890abcdef")); //IV

			cipher = new BufferedBlockCipher(new GOfbBlockCipher(new Gost28147Engine()));

			cipher.Init(true, param);
			len1 = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0);

			cipher.DoFinal(outBytes, len1);

			if (outBytes.Length != output.Length)
			{
				Fail("failed - "
					+ "expected " + Hex.ToHexString(output)
					+ " got " + Hex.ToHexString(outBytes));
			}

			for (int i = 0; i != outBytes.Length; i++)
			{
				if (outBytes[i] != output[i])
				{
					Fail("failed - "
						+ "expected " + Hex.ToHexString(output)
						+ " got " + Hex.ToHexString(outBytes));
				}
			}
		}
Exemplo n.º 34
0
		private IBufferedCipher createCipher(bool forEncryption)
		{
//			IBufferedCipher cipher = CipherUtilities.GetCipher("AES/CFB/NoPadding");

			IBlockCipher blockCipher = new AesEngine();
			int bits = 8 * blockCipher.GetBlockSize(); // TODO Is this right?
			blockCipher = new CfbBlockCipher(blockCipher, bits);
			IBufferedCipher cipher = new BufferedBlockCipher(blockCipher);

//			SecureRandom random = new SecureRandom();
			byte[] keyBytes = new byte[32];
			//random.NextBytes(keyBytes);
			KeyParameter key = new KeyParameter(keyBytes);

			byte[] iv = new byte[cipher.GetBlockSize()];
			//random.NextBytes(iv);

			cipher.Init(forEncryption, new ParametersWithIV(key, iv));

			return cipher;
		}