private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, string key) { try { _cipher = _padding == null ? new PaddedBufferedBlockCipher(_blockCipher) : new PaddedBufferedBlockCipher(_blockCipher, _padding); int paddingchar = 16 - key.Length; for (int i = 0; i < paddingchar; i++) { key += " "; } key = key.Substring(0, 16); byte[] keyByte = _encoding.GetBytes(key); _cipher.Init(forEncrypt, new KeyParameter(keyByte)); return(_cipher.DoFinal(input)); } catch (Org.BouncyCastle.Crypto.CryptoException ex) { // throw new CryptoException(ex); } return(null); }
private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, string key) { _cipher = _padding == null ? new PaddedBufferedBlockCipher(_blockCipher) : new PaddedBufferedBlockCipher(_blockCipher, _padding); byte[] keyByte = _encoding.GetBytes(key); _cipher.Init(forEncrypt, new KeyParameter(keyByte)); return _cipher.DoFinal(input); }
private void blockCheck( PaddedBufferedBlockCipher cipher, IBlockCipherPadding padding, KeyParameter key, byte[] data) { byte[] outBytes = new byte[data.Length + 8]; byte[] dec = new byte[data.Length]; try { cipher.Init(true, key); int len = cipher.ProcessBytes(data, 0, data.Length, outBytes, 0); len += cipher.DoFinal(outBytes, len); cipher.Init(false, key); int decLen = cipher.ProcessBytes(outBytes, 0, len, dec, 0); decLen += cipher.DoFinal(dec, decLen); if (!AreEqual(data, dec)) { Fail("failed to decrypt - i = " + data.Length + ", padding = " + padding.PaddingName); } } catch (Exception e) { Fail("Exception - " + e.ToString(), e); } }
private static byte[] Decrypt(byte[] bytes, byte[] key) { var engine = new BlowfishEngine(); var chiper = new PaddedBufferedBlockCipher(engine); var keyParameter = new KeyParameter(key); chiper.Init(false, keyParameter); return chiper.DoFinal(bytes); }
/** Creates a new instance of AESCipher */ public AESCipher(bool forEncryption, byte[] key, byte[] iv) { IBlockCipher aes = new AesFastEngine(); IBlockCipher cbc = new CbcBlockCipher(aes); bp = new PaddedBufferedBlockCipher(cbc); KeyParameter kp = new KeyParameter(key); ParametersWithIV piv = new ParametersWithIV(kp, iv); bp.Init(forEncryption, piv); }
private static string Cipher(bool encrypt, byte[] key, byte[] data) { PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(cipherEngine, padding); cipher.Init(encrypt, new KeyParameter(key)); int size = cipher.GetOutputSize(data.Length); byte[] result = new byte[size]; int position = cipher.ProcessBytes(data, 0, data.Length, result, 0); cipher.DoFinal(result, position); return encrypt ? BitConverter.ToString(result).Replace("-", String.Empty).ToLower() : encoding.GetString(result); }
/// <summary> /// /// </summary> /// <param name="forEncrypt"></param> /// <param name="input"></param> /// <param name="key"></param> /// <returns></returns> /// <exception cref="CryptoException"></exception> private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, string key) { try { _cipher = _padding == null ? new PaddedBufferedBlockCipher(_blockCipher) : new PaddedBufferedBlockCipher(_blockCipher, _padding); byte[] keyByte = _encoding.GetBytes(key); _cipher.Init(forEncrypt, new KeyParameter(keyByte)); return _cipher.DoFinal(input); } catch (Org.BouncyCastle.Crypto.CryptoException ex) { throw new CryptoException("BCEngine CryptoException", ex); } }
public override void PerformTest() { BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new DesEngine())); SimpleTest test = new PbeTest(this, 0, cipher, sample1, 64); test.PerformTest(); cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new DesEdeEngine())); test = new PbeTest(this, 1, cipher, sample2, 192); test.PerformTest(); cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new RC2Engine())); test = new PbeTest(this, 2, cipher, sample3, 0); test.PerformTest(); // // RFC 3211 tests // char[] password = "******".ToCharArray(); PbeParametersGenerator generator = new Pkcs5S2ParametersGenerator(); byte[] salt = Hex.Decode("1234567878563412"); generator.Init( PbeParametersGenerator.Pkcs5PasswordToBytes(password), salt, 5); if (!AreEqual(((KeyParameter)generator.GenerateDerivedParameters("DES", 64)).GetKey(), Hex.Decode("d1daa78615f287e6"))) { Fail("64 test failed"); } password = "******".ToCharArray(); generator.Init( PbeParametersGenerator.Pkcs5PasswordToBytes(password), salt, 500); if (!AreEqual(((KeyParameter)generator.GenerateDerivedParameters("DESEDE", 192)).GetKey(), Hex.Decode("6a8970bf68c92caea84a8df28510858607126380cc47ab2d"))) { Fail("192 test failed"); } }
public void doTestPadding( IBlockCipherPadding padding, SecureRandom rand, byte[] ffVector, byte[] ZeroVector) { PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new DesEngine(), padding); KeyParameter key = new KeyParameter(Hex.Decode("0011223344556677")); // // ff test // byte[] data = { (byte)0xff, (byte)0xff, (byte)0xff, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0 }; if (ffVector != null) { padding.AddPadding(data, 3); if (!AreEqual(data, ffVector)) { Fail("failed ff test for " + padding.PaddingName); } } // // zero test // if (ZeroVector != null) { data = new byte[8]; padding.AddPadding(data, 4); if (!AreEqual(data, ZeroVector)) { Fail("failed zero test for " + padding.PaddingName); } } for (int i = 1; i != 200; i++) { data = new byte[i]; rand.NextBytes(data); blockCheck(cipher, padding, key, data); } }
public static AesEncyrption getInstance() { if (instance == null) { try { if (string.IsNullOrEmpty(_encryptionKey)) { Initalize(); } AesEncyrption bcEngine = new AesEncyrption(); KeyParameter keyParam = new KeyParameter(Encoding.UTF8.GetBytes(_encryptionKey)); ICipherParameters param = new ParametersWithIV(keyParam, iv); //create decrypt/encryptor cipher IBlockCipherPadding padding = new Pkcs7Padding(); BufferedBlockCipher decrypt = new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesEngine()), padding); decrypt.Reset(); decrypt.Init(false, param); bcEngine.setDecryptCipher(decrypt); BufferedBlockCipher encrypt = new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesEngine()), padding); encrypt.Reset(); encrypt.Init(true, param); bcEngine.setEncryptCipher(encrypt); instance = bcEngine; } catch (Exception) { throw; } } return instance; }
/// <summary> /// Symmetric encryption with AES/CBC/PKCS7. /// </summary> /// <param name="message">Message to be encrypted.</param> /// <param name="key">Private key for use with encryption.</param> /// <returns>Message in cipher text.</returns> public static byte[] Encrypt( byte[] message, byte[] key ) { PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher( new CbcBlockCipher( new AesEngine() ), new Pkcs7Padding() ); cipher.Init( true, new KeyParameter( key ) ); return cipher.DoFinal( message ); }
/// <summary> /// Symmetric decryption with AES/CBC/PKCS7. /// </summary> /// <param name="cipherText">Message to be decrypted.</param> /// <param name="key">Private key for use with decryption.</param> /// <returns>Plain text message.</returns> public static byte[] Decrypt( byte[] cipherText, byte[] key ) { PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher( new CbcBlockCipher( new AesEngine() ), new Pkcs7Padding() ); cipher.Init( false, new KeyParameter( key ) ); return cipher.DoFinal( cipherText ); }
/// <summary> /// Decrypt a hex-coded string using our MD5 or PBKDF2 generated key /// </summary> /// <param name="data">data string to be decrypted</param> /// <param name="key">decryption key</param> /// <param name="PBKDF2">flag to indicate we are using PBKDF2 to generate derived key</param> /// <returns>hex coded decrypted string</returns> public static string Decrypt(string data, string password, bool PBKDF2) { byte[] key; byte[] saltBytes = Authenticator.StringToByteArray(data.Substring(0, SALT_LENGTH * 2)); if (PBKDF2 == true) { // extract the salt from the data byte[] passwordBytes = Encoding.UTF8.GetBytes(password); // build our PBKDF2 key #if NETCF PBKDF2 kg = new PBKDF2(passwordBytes, saltbytes, 2000); #else Rfc2898DeriveBytes kg = new Rfc2898DeriveBytes(passwordBytes, saltBytes, PBKDF2_ITERATIONS); #endif key = kg.GetBytes(PBKDF2_KEYSIZE); } else { // extract the salt from the data byte[] passwordBytes = Encoding.UTF8.GetBytes(password); key = new byte[saltBytes.Length + passwordBytes.Length]; Array.Copy(saltBytes, key, saltBytes.Length); Array.Copy(passwordBytes, 0, key, saltBytes.Length, passwordBytes.Length); // build out combined key SHA256Managed md5 =new SHA256Managed(); key = md5.ComputeHash(key); } // extract the actual data to be decrypted byte[] inBytes = Authenticator.StringToByteArray(data.Substring(SALT_LENGTH * 2)); // get cipher BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new BlowfishEngine(), new ISO10126d2Padding()); cipher.Init(false, new KeyParameter(key)); // decrypt the data int osize = cipher.GetOutputSize(inBytes.Length); byte[] outBytes = new byte[osize]; try { int olen = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0); olen += cipher.DoFinal(outBytes, olen); if (olen < osize) { byte[] t = new byte[olen]; Array.Copy(outBytes, 0, t, 0, olen); outBytes = t; } } catch (Exception) { // an exception is due to bad password throw new BadPasswordException(); } // return encoded string return Authenticator.ByteArrayToString(outBytes); }
/// <summary> /// Encrypt a string with a given key /// </summary> /// <param name="plain">data to encrypt - hex representation of byte array</param> /// <param name="key">key to use to encrypt</param> /// <returns>hex coded encrypted string</returns> public static string Encrypt(string plain, string password) { byte[] inBytes = Authenticator.StringToByteArray(plain); byte[] passwordBytes = Encoding.UTF8.GetBytes(password); // build a new salt RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider(); byte[] saltbytes = new byte[SALT_LENGTH]; rg.GetBytes(saltbytes); string salt = Authenticator.ByteArrayToString(saltbytes); // build our PBKDF2 key #if NETCF PBKDF2 kg = new PBKDF2(passwordBytes, saltbytes, PBKDF2_ITERATIONS); #else Rfc2898DeriveBytes kg = new Rfc2898DeriveBytes(passwordBytes, saltbytes, PBKDF2_ITERATIONS); #endif byte[] key = kg.GetBytes(PBKDF2_KEYSIZE); // get our cipher BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new BlowfishEngine(), new ISO10126d2Padding()); cipher.Init(true, new KeyParameter(key)); // encrypt data int osize = cipher.GetOutputSize(inBytes.Length); byte[] outBytes = new byte[osize]; int olen = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0); olen += cipher.DoFinal(outBytes, olen); if (olen < osize) { byte[] t = new byte[olen]; Array.Copy(outBytes, 0, t, 0, olen); outBytes = t; } // return encoded byte->hex string return salt + Authenticator.ByteArrayToString(outBytes); }
/// <summary> /// Encrypts using AES256Cbc and a password /// </summary> /// <param name="password"></param> /// <param name="plainText"></param> /// <returns></returns> public static byte[] Encrypt(string plainText, string password) { // If text to encrypt is null, return null if (string.IsNullOrWhiteSpace(plainText)) { return null; } // Generate a random salt var saltBytes = GenerateSalt(); //create cipher engine var cipher = new PaddedBufferedBlockCipher( new CbcBlockCipher( new AesEngine())); //get the key parameters from the password var key = GenerateKey(password, saltBytes); //initialize for encryption with the key cipher.Init(true, key); // Convert plain text string to bytes var plainBytes = Encoding.UTF8.GetBytes(plainText); MemoryStream cipherStream; //process the input using (cipherStream = new MemoryStream()) { //write iv cipherStream.Write(key.GetIV(), 0, key.GetIV().Length); //write salt cipherStream.Write(saltBytes, 0, saltBytes.Length); byte[] outputBytes; //get output outputBytes = cipher.ProcessBytes(plainBytes); if (outputBytes != null) { //write the data to the stream cipherStream.Write(outputBytes, 0, outputBytes.Length); } //do the final block outputBytes = cipher.DoFinal(); if (outputBytes != null) { //write the data to the stream cipherStream.Write(outputBytes, 0, outputBytes.Length); } } //return the bytes return cipherStream.ToArray(); }
/// <summary> /// Encapsulates the specified links into a CCF container. /// </summary> /// <param name="name">The name of the package.</param> /// <param name="links">The links.</param> /// <returns> /// CCF container. /// </returns> public static byte[] CreateCCF(string name, string[] links) { var sb = new StringBuilder(); sb.Append("<?xml version=\"1.0\" encoding=\"utf-8\"?>"); sb.Append("<CryptLoad>"); sb.Append("<Package service=\"\" name=\"" + name + "\" url=\"Directlinks\">"); foreach (var link in links) { sb.Append("<Download Url=\"" + link + "\">"); sb.Append("<Url>" + link + "</Url>"); //sb.Append("<FileName></FileName>"); //sb.Append("<FileSize></FileSize>"); sb.Append("</Download>"); } sb.Append("</Package>"); sb.Append("</CryptLoad>"); var aes = new AesEngine(); var cbc = new CbcBlockCipher(aes); var pk7 = new Pkcs7Padding(); var pad = new PaddedBufferedBlockCipher(cbc, pk7); pad.Init(true, new ParametersWithIV(new KeyParameter(CCFKey), CCFIV)); return pad.DoFinal(Encoding.UTF8.GetBytes(sb.ToString())); }
/// <summary> /// The encrypt. /// </summary> /// <param name="data"> /// The data. /// </param> /// <param name="key"> /// The key. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> private string Encrypt(string data, SecretKey key) { byte[] bytes = Encoding.UTF8.GetBytes(data); // Setup the DESede cipher engine, create a PaddedBufferedBlockCipher in CBC mode. byte[] keyBytes = key.GetBytes(); var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new DesEdeEngine())); // initialise the cipher with the key bytes, for encryption cipher.Init(true, new KeyParameter(keyBytes)); int inBlockSize = bytes.Length; int outBlockSize = cipher.GetOutputSize(inBlockSize); var inblock = bytes; var outblock = new byte[outBlockSize]; cipher.ProcessBytes(inblock, 0, inBlockSize, outblock, 0); cipher.DoFinal(outblock, 0); return Convert.ToBase64String(outblock); }
private void EncryptDataAes256CbcPkcs7(byte[] dataToEncrypt) { if (_key != null && _key.Length != 32) throw new Exception("Explicit data encryption key is not of required length for encryption method"); if (_key == null) { // No explicit key was provided, we're going to generate our own. _key = new byte[32]; RandomUtil.SecureRandomBc.NextBytes(_key); } _iv = new byte[16]; RandomUtil.SecureRandomBc.NextBytes(_iv); var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesFastEngine()), new Pkcs7Padding()); cipher.Init(true, new ParametersWithIV(new KeyParameter(_key), _iv)); _data = cipher.DoFinal(dataToEncrypt); }
/// <summary> /// Decrypt AES256-CBC with PKCS7 padding data /// </summary> /// <param name="encryptionKey"></param> /// <param name="encryptedDataStream"></param> /// <param name="outputStream"></param> private static void DecryptDataAes256CbcPkcs7( byte[] encryptionKey, Stream encryptedDataStream, Stream outputStream) { if (encryptionKey.Length != 32) throw new Exception("AES256 encryption key not of expected length"); var iv = new byte[16]; var ivBytesRead = encryptedDataStream.Read(iv, 0, 16); if (ivBytesRead != 16) throw new Exception("Unexpected IV"); // The rest of the data stream is the encrypted data itself. var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new AesFastEngine()), new Pkcs7Padding()); cipher.Init(false, new ParametersWithIV(new KeyParameter(encryptionKey), iv)); while (true) { var buffer = new byte[4096]; var dataBytesRead = encryptedDataStream.Read(buffer, 0, 4096); if (dataBytesRead == 0) break; var processedBytes = cipher.ProcessBytes(buffer, 0, dataBytesRead); if (processedBytes != null) outputStream.Write(processedBytes, 0, processedBytes.Length); } var finalBytes = cipher.DoFinal(); outputStream.Write(finalBytes, 0, finalBytes.Length); }
private void StaticTest() { FpCurve curve = new FpCurve( new BigInteger("6277101735386680763835789423207666416083908700390324961279"), // q new BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), // a new BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16)); // b ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012")), // G new BigInteger("6277101735386680763835789423176059013767194773182842284081")); // n ECPrivateKeyParameters priKey = new ECPrivateKeyParameters( "ECDH", new BigInteger("651056770906015076056810763456358567190100156695615665659"), // d parameters); ECPublicKeyParameters pubKey = new ECPublicKeyParameters( "ECDH", curve.DecodePoint(Hex.Decode("0262b12d60690cdcf330babab6e69763b471f994dd702d16a5")), // Q parameters); AsymmetricCipherKeyPair p1 = new AsymmetricCipherKeyPair(pubKey, priKey); AsymmetricCipherKeyPair p2 = new AsymmetricCipherKeyPair(pubKey, priKey); // // stream test // IesEngine i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); IesEngine i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); byte[] d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; byte[] e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; IesParameters p = new IesParameters(d, e, 64); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); byte[] message = Hex.Decode("1234567890abcdef"); byte[] out1 = i1.ProcessBlock(message, 0, message.Length); if (!AreEqual(out1, Hex.Decode("2442ae1fbf90dd9c06b0dcc3b27e69bd11c9aee4ad4cfc9e50eceb44"))) { Fail("stream cipher test failed on enc"); } byte[] out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("stream cipher test failed"); } // // twofish with CBC // BufferedBlockCipher c1 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); BufferedBlockCipher c2 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c1); i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c2); d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; p = new IesWithCipherParameters(d, e, 64, 128); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); message = Hex.Decode("1234567890abcdef"); out1 = i1.ProcessBlock(message, 0, message.Length); if (!AreEqual(out1, Hex.Decode("2ea288651e21576215f2424bbb3f68816e282e3931b44bd1c429ebdb5f1b290cf1b13309"))) { Fail("twofish cipher test failed on enc"); } out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("twofish cipher test failed"); } }
/// <summary> /// The decrypt. /// </summary> /// <param name="encrypted"> /// The encrypted. /// </param> /// <param name="key"> /// The key. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> private string Decrypt(string encrypted, SecretKey key) { byte[] bytes = Convert.FromBase64String(encrypted); byte[] keyBytes = key.GetBytes(); // initialise the cipher for decryption var cipher = new PaddedBufferedBlockCipher(new CbcBlockCipher(new DesEdeEngine())); cipher.Init(false, new KeyParameter(keyBytes)); int inBlockSize = bytes.Length; int outBlockSize = cipher.GetOutputSize(inBlockSize); var inblock = bytes; var outblock = new byte[outBlockSize]; cipher.ProcessBytes(inblock, 0, inBlockSize, outblock, 0); cipher.DoFinal(outblock, 0); var clear = this.ToUTF8String(outblock); return clear; }
private void DoTest( AsymmetricCipherKeyPair p1, AsymmetricCipherKeyPair p2) { // // stream test // IesEngine i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); IesEngine i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); byte[] d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; byte[] e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; IesParameters p = new IesParameters(d, e, 64); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); byte[] message = Hex.Decode("1234567890abcdef"); byte[] out1 = i1.ProcessBlock(message, 0, message.Length); byte[] out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("stream cipher test failed"); } // // twofish with CBC // BufferedBlockCipher c1 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); BufferedBlockCipher c2 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c1); i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c2); d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; p = new IesWithCipherParameters(d, e, 64, 128); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); message = Hex.Decode("1234567890abcdef"); out1 = i1.ProcessBlock(message, 0, message.Length); out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("twofish cipher test failed"); } }
private void DoCbc(byte[] key, byte[] iv, byte[] pt, byte[] expected) { PaddedBufferedBlockCipher c = new PaddedBufferedBlockCipher(new CbcBlockCipher(new SerpentEngine()), new Pkcs7Padding()); byte[] ct = new byte[expected.Length]; c.Init(true, new ParametersWithIV(new KeyParameter(key), iv)); int l = c.ProcessBytes(pt, 0, pt.Length, ct, 0); c.DoFinal(ct, l); if (!Arrays.AreEqual(expected, ct)) { Fail("CBC test failed"); } }
private void process() { /* * Setup the DESede cipher engine, create a PaddedBufferedBlockCipher * in CBC mode. */ cipher = new PaddedBufferedBlockCipher( new CbcBlockCipher(new DesEdeEngine())); /* * The input and output streams are currently set up * appropriately, and the key bytes are ready to be * used. * */ if (encrypt) { performEncrypt(key); } else { performDecrypt(key); } // after processing clean up the files try { inStr.Close(); outStr.Flush(); outStr.Close(); } catch (IOException) { } }
/// <summary> /// Decrypt a hex-encoded string with a byte array key /// </summary> /// <param name="data">hex-encoded string</param> /// <param name="key">key for decryption</param> /// <returns>hex-encoded plain text</returns> public static string Decrypt(string data, byte[] key) { // the actual data to be decrypted byte[] inBytes = Authenticator.StringToByteArray(data); // get cipher BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new BlowfishEngine(), new ISO10126d2Padding()); cipher.Init(false, new KeyParameter(key)); // decrypt the data int osize = cipher.GetOutputSize(inBytes.Length); byte[] outBytes = new byte[osize]; try { int olen = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0); olen += cipher.DoFinal(outBytes, olen); if (olen < osize) { byte[] t = new byte[olen]; Array.Copy(outBytes, 0, t, 0, olen); outBytes = t; } } catch (Exception) { // an exception is due to bad password throw new BadPasswordException(); } // return encoded string return Authenticator.ByteArrayToString(outBytes); }
private static Stream CreateStream(Stream s, bool bEncrypt, byte[] pbKey, byte[] pbIV) { StandardAesEngine.ValidateArguments(s, bEncrypt, pbKey, pbIV); byte[] pbLocalIV = new byte[16]; Array.Copy(pbIV, pbLocalIV, 16); byte[] pbLocalKey = new byte[32]; Array.Copy(pbKey, pbLocalKey, 32); #if !KeePassRT RijndaelManaged r = new RijndaelManaged(); if(r.BlockSize != 128) // AES block size { Debug.Assert(false); r.BlockSize = 128; } r.IV = pbLocalIV; r.KeySize = 256; r.Key = pbLocalKey; r.Mode = m_rCipherMode; r.Padding = m_rCipherPadding; ICryptoTransform iTransform = (bEncrypt ? r.CreateEncryptor() : r.CreateDecryptor()); Debug.Assert(iTransform != null); if(iTransform == null) throw new SecurityException("Unable to create Rijndael transform!"); return new CryptoStream(s, iTransform, bEncrypt ? CryptoStreamMode.Write : CryptoStreamMode.Read); #else AesEngine aes = new AesEngine(); CbcBlockCipher cbc = new CbcBlockCipher(aes); PaddedBufferedBlockCipher bc = new PaddedBufferedBlockCipher(cbc, new Pkcs7Padding()); KeyParameter kp = new KeyParameter(pbLocalKey); ParametersWithIV prmIV = new ParametersWithIV(kp, pbLocalIV); bc.Init(bEncrypt, prmIV); IBufferedCipher cpRead = (bEncrypt ? null : bc); IBufferedCipher cpWrite = (bEncrypt ? bc : null); return new CipherStream(s, cpRead, cpWrite); #endif }
/// <summary> /// Decrypts cypher data /// </summary> /// <param name="cipherData"></param> /// <param name="password"></param> /// <returns></returns> public static string Decrypt(byte[] cipherData, string password) { // If there is no cipher data, return null if (cipherData == null) { return null; } //extract the iv and salt byte[] ivBytes = new byte[IV_LENGTH]; byte[] saltBytes = new byte[SALT_LENGTH]; byte[] cipherBytes = new byte[cipherData.Length - (ivBytes.Length + saltBytes.Length)]; //process the input using (var cipherStream = new MemoryStream(cipherData)) { //read iv cipherStream.Read(ivBytes, 0, ivBytes.Length); //read salt cipherStream.Read(saltBytes, 0, saltBytes.Length); //read cipher bytes cipherStream.Read(cipherBytes, 0, cipherBytes.Length); } //create cipher engine var cipher = new PaddedBufferedBlockCipher( new CbcBlockCipher( new AesEngine())); //get the key parameters from the password var key = GenerateKey(password, saltBytes, ivBytes); //initialize for decryption with the key cipher.Init(false, key); MemoryStream plainStream; //process the input using (plainStream = new MemoryStream()) { byte[] outputBytes; //get output outputBytes = cipher.ProcessBytes(cipherBytes); if (outputBytes != null) { //write the data to the stream plainStream.Write(outputBytes, 0, outputBytes.Length); } //do the final block outputBytes = cipher.DoFinal(); if (outputBytes != null) { //write the data to the stream plainStream.Write(outputBytes, 0, outputBytes.Length); } } return Encoding.UTF8.GetString(plainStream.ToArray()); }
/// <summary> /// Encapsulates the specified links into a DLC container. /// </summary> /// <param name="name">The name of the package.</param> /// <param name="links">The links.</param> /// <returns> /// Base-64-encoded DLC container. /// </returns> public static string CreateDLC(string name, string[] links) { var sb = new StringBuilder(); sb.Append("<dlc>"); sb.Append("<header>"); sb.Append("<generator>"); sb.Append("<app>" + Convert.ToBase64String(Encoding.UTF8.GetBytes("RS TV Show Tracker")) + "</app>"); sb.Append("<version>" + Convert.ToBase64String(Encoding.UTF8.GetBytes("1.0")) + "</version>"); sb.Append("<url>" + Convert.ToBase64String(Encoding.UTF8.GetBytes("http://lab.rolisoft.net/")) + "</url>"); sb.Append("</generator>"); sb.Append("<dlcxmlversion>" + Convert.ToBase64String(Encoding.UTF8.GetBytes("20_02_2008")) + "</dlcxmlversion>"); sb.Append("</header>"); sb.Append("<content>"); sb.Append("<package name=\"" + Convert.ToBase64String(Encoding.UTF8.GetBytes(name)) + "\">"); foreach (var link in links) { sb.Append("<file>"); sb.Append("<url>" + Convert.ToBase64String(Encoding.UTF8.GetBytes(link)) + "</url>"); //sb.Append("<filename></filename>"); //sb.Append("<size></size>"); sb.Append("</file>"); } sb.Append("</package>"); sb.Append("</content>"); sb.Append("</dlc>"); var xml = Convert.ToBase64String(Encoding.UTF8.GetBytes(sb.ToString())); var key = BitConverter.ToString(new SHA256CryptoServiceProvider().ComputeHash(BitConverter.GetBytes(DateTime.Now.ToBinary()))).Replace("-", string.Empty).Substring(0, 16); var srv = Utils.GetURL(DLCCrypt, "&data=" + key + "&lid=" + Convert.ToBase64String(Encoding.UTF8.GetBytes("http://lab.rolisoft.net/_3600")) + "&version=1.0&client=rstvshowtracker"); var rcr = Regex.Match(srv, @"<rc>(.+)</rc>"); if (!rcr.Groups[1].Success) { throw new Exception("The jDownloader DLC encryption service did not return an encryption key."); } var enc = rcr.Groups[1].Value; var aes = new AesEngine(); var cbc = new CbcBlockCipher(aes); var zbp = new ZeroBytePadding(); var pad = new PaddedBufferedBlockCipher(cbc, zbp); pad.Init(true, new ParametersWithIV(new KeyParameter(Encoding.ASCII.GetBytes(key)), Encoding.ASCII.GetBytes(key))); var xm2 = Convert.ToBase64String(pad.DoFinal(Encoding.ASCII.GetBytes(xml))); return xm2 + enc; }
/// <summary> /// Encrypt a string with a byte array key /// </summary> /// <param name="plain">data to encrypt - hex representation of byte array</param> /// <param name="passwordBytes">key to use to encrypt</param> /// <returns>hex coded encrypted string</returns> public static string Encrypt(string plain, byte[] key) { byte[] inBytes = Authenticator.StringToByteArray(plain); // get our cipher BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new BlowfishEngine(), new ISO10126d2Padding()); cipher.Init(true, new KeyParameter(key)); // encrypt data int osize = cipher.GetOutputSize(inBytes.Length); byte[] outBytes = new byte[osize]; int olen = cipher.ProcessBytes(inBytes, 0, inBytes.Length, outBytes, 0); olen += cipher.DoFinal(outBytes, olen); if (olen < osize) { byte[] t = new byte[olen]; Array.Copy(outBytes, 0, t, 0, olen); outBytes = t; } // return encoded byte->hex string return Authenticator.ByteArrayToString(outBytes); }
private void StaticTest() { FpCurve curve = new FpCurve( new BigInteger("6277101735386680763835789423207666416083908700390324961279"), // q new BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), // a new BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16)); // b ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012")), // G new BigInteger("6277101735386680763835789423176059013767194773182842284081")); // n ECPrivateKeyParameters priKey = new ECPrivateKeyParameters( "ECDH", new BigInteger("651056770906015076056810763456358567190100156695615665659"), // d parameters); ECPublicKeyParameters pubKey = new ECPublicKeyParameters( "ECDH", curve.DecodePoint(Hex.Decode("0262b12d60690cdcf330babab6e69763b471f994dd702d16a5")), // Q parameters); AsymmetricCipherKeyPair p1 = new AsymmetricCipherKeyPair(pubKey, priKey); AsymmetricCipherKeyPair p2 = new AsymmetricCipherKeyPair(pubKey, priKey); // // stream test // IesEngine i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); IesEngine i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest())); byte[] d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; byte[] e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; IesParameters p = new IesParameters(d, e, 64); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); byte[] message = Hex.Decode("1234567890abcdef"); byte[] out1 = i1.ProcessBlock(message, 0, message.Length); if (!AreEqual(out1, Hex.Decode("468d89877e8238802403ec4cb6b329faeccfa6f3a730f2cdb3c0a8e8"))) { Fail("stream cipher test failed on enc"); } byte[] out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("stream cipher test failed"); } // // twofish with CBC // BufferedBlockCipher c1 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); BufferedBlockCipher c2 = new PaddedBufferedBlockCipher( new CbcBlockCipher(new TwofishEngine())); i1 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c1); i2 = new IesEngine( new ECDHBasicAgreement(), new Kdf2BytesGenerator(new Sha1Digest()), new HMac(new Sha1Digest()), c2); d = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; e = new byte[] { 8, 7, 6, 5, 4, 3, 2, 1 }; p = new IesWithCipherParameters(d, e, 64, 128); i1.Init(true, p1.Private, p2.Public, p); i2.Init(false, p2.Private, p1.Public, p); message = Hex.Decode("1234567890abcdef"); out1 = i1.ProcessBlock(message, 0, message.Length); if (!AreEqual(out1, Hex.Decode("b8a06ea5c2b9df28b58a0a90a734cde8c9c02903e5c220021fe4417410d1e53a32a71696"))) { Fail("twofish cipher test failed on enc"); } out2 = i2.ProcessBlock(out1, 0, out1.Length); if (!AreEqual(out2, message)) { Fail("twofish cipher test failed"); } }
private void EncryptUsingBC(Stream istream, Stream ostream, byte[] iv, bool forEncryption) { var padding = ((TypeWrapper) BlockCipherModel.Padding).Instance<IBlockCipherPadding>(); var engine = BlockCipherModel.Engine.Instance<IBlockCipher>(); var mode = ((TypeWrapper) BlockCipherModel.Mode).Instance<IBlockCipher>(engine); var cipher = new PaddedBufferedBlockCipher(mode, padding); var buf = new byte[16]; //input buffer var obuf = new byte[512]; //output buffer int noBytesRead; //number of bytes read from input int noBytesProcessed ; //number of bytes processed var p = new ParametersWithIV(new KeyParameter(PbkdfModel.Key), iv); cipher.Init(forEncryption, p); // Buffer used to transport the bytes from one stream to another while ((noBytesRead = istream.Read(buf, 0, Blocksize)) > 0) { //System.out.println(noBytesRead +" bytes read"); noBytesProcessed = cipher.ProcessBytes(buf, 0, noBytesRead, obuf, 0); //System.out.println(noBytesProcessed +" bytes processed"); ostream.Write(obuf, 0, noBytesProcessed); } //System.out.println(noBytesRead +" bytes read"); noBytesProcessed = cipher.DoFinal(obuf, 0); //System.out.println(noBytesProcessed +" bytes processed"); ostream.Write(obuf, 0, noBytesProcessed); ostream.Flush(); }