GenerateIV() public method

public GenerateIV ( ) : void
return void
コード例 #1
0
        public byte[] Encription(string message, byte[] bobPubKeyBlob)
        {
            byte[] rawData = Encoding.UTF8.GetBytes(message);
            byte[] encryptedData = null;

            using (var aliceAlgorithm = new ECDiffieHellmanCng(privKey))
            using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob,
                  CngKeyBlobFormat.EccPublicBlob))
            {
                byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey);
                using (var aes = new AesCryptoServiceProvider())
                {
                    aes.Key = symmKey;
                    aes.GenerateIV();
                    using (ICryptoTransform encryptor = aes.CreateEncryptor())
                    using (MemoryStream ms = new MemoryStream())
                    {
                        // create CryptoStream and encrypt data to send
                        var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);

                        // write initialization vector not encrypted
                        ms.Write(aes.IV, 0, aes.IV.Length);
                        cs.Write(rawData, 0, rawData.Length);
                        cs.Close();
                        encryptedData = ms.ToArray();
                    }
                    aes.Clear();
                }
            }
            return encryptedData;
        }
コード例 #2
0
ファイル: Global.asax.cs プロジェクト: calexander3/Damage
        protected void Application_Start()
        {
            //HibernatingRhinos.Profiler.Appender.EntityFramework.EntityFrameworkProfiler.Initialize();
            log4net.Config.XmlConfigurator.ConfigureAndWatch(new FileInfo(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log4net.config")));
            GlobalConfig.Log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();

            var container = new Container();
            SimpleInjectorInitializer.InitializeInjector(container);
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));

            GlobalConfig.ConnectionString = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
            GlobalConfig.GadgetTypes = new System.Collections.Concurrent.ConcurrentDictionary<string, Type>();

            LoadGadgets();

            var aesCsp = new AesCryptoServiceProvider();
            aesCsp.GenerateKey();
            aesCsp.GenerateIV();
            GlobalConfig.Encryptor = new SimpleAES(aesCsp.Key, aesCsp.IV);
        }
コード例 #3
0
 /// <summary>
 /// Generates a unique encryption vector
 /// </summary>
 /// <returns>byte[] vector value</returns>
 static public byte[] GenerateEncryptionVector()
 {
     //Generate a Vector
     var aesProvider = new AesCryptoServiceProvider();
     aesProvider.GenerateIV();
     return aesProvider.IV;
 }
コード例 #4
0
ファイル: FormMain.cs プロジェクト: alexbikfalvi/DotNetApi
        private void OnGenerate(object sender, EventArgs e)
        {
            // Create the AES provider.
            using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
            {
                // Generate the IV.
                aesProvider.GenerateIV();
                // Generate the key.
                aesProvider.GenerateKey();

                StringBuilder builder = new StringBuilder();

                foreach (byte b in aesProvider.IV)
                {
                    builder.AppendFormat("0x{0:X2}, ", b);
                }

                this.textBoxIv.Text = builder.ToString();

                builder.Clear();

                foreach(byte b in aesProvider.Key)
                {
                    builder.AppendFormat("0x{0:X2}, ", b);
                }

                this.textBoxKey.Text = builder.ToString();
            }
        }
コード例 #5
0
ファイル: FileEncryption.cs プロジェクト: Jupotter/virologie
        public void Encrypt(string filename)
        {
            FileStream fsInput = new FileStream(filename, FileMode.Open, FileAccess.Read);
            FileStream fsOutput = new FileStream(filename + ".crypt", FileMode.Create, FileAccess.Write);
            AesCryptoServiceProvider Aes = new AesCryptoServiceProvider();

            Aes.KeySize = 128;
            Aes.GenerateIV();
            Aes.GenerateKey();

            byte[] output = _algorithm_asym.Encrypt(Aes.Key, false);
            fsOutput.Write(output, 0, 256);
            output = _algorithm_asym.Encrypt(Aes.IV, false);
            fsOutput.Write(output, 0, 256);

            ICryptoTransform encrypt = Aes.CreateEncryptor();
            CryptoStream cryptostream = new CryptoStream(fsOutput, encrypt, CryptoStreamMode.Write);

            byte[] bytearrayinput = new byte[fsInput.Length - 1];
            fsInput.Read(bytearrayinput, 0, bytearrayinput.Length);
            cryptostream.Write(bytearrayinput, 0, bytearrayinput.Length);

            fsInput.Close();
            fsOutput.Close();
        }
コード例 #6
0
        private static byte[] AliceSendData(string msg)
        {
            Console.WriteLine(string.Format("Alice Send Msg: {0}", msg));
            byte[] rawdata = Encoding.UTF8.GetBytes(msg);
            byte[] encryptedData = null;
            using (var aliceAlgorithm = new ECDiffieHellmanCng(aliceKey))
            using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob))
            {
                byte[] symmkey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey);

                Console.WriteLine(string.Format("Alice Create this symmtric key with {0}", Convert.ToBase64String(symmkey)));

                var aes = new AesCryptoServiceProvider();
                aes.Key = symmkey;
                aes.GenerateIV();
                using (ICryptoTransform encryptor = aes.CreateEncryptor())
                using (MemoryStream ms = new MemoryStream())
                {
                    var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
                    ms.Write(aes.IV, 0, aes.IV.Length);
                    cs.Write(rawdata, 0, rawdata.Length);
                    cs.Close();
                    encryptedData = ms.ToArray();
                }
                aes.Clear();
            }

            Console.WriteLine(Convert.ToBase64String(encryptedData));
            return encryptedData;
        }
コード例 #7
0
ファイル: AES.cs プロジェクト: yashodhank/QuasarRAT
        public static byte[] Encrypt(byte[] input, byte[] key)
        {
            if (key == null || key.Length == 0) throw new Exception("Key can not be empty.");

            using (var md5 = new MD5CryptoServiceProvider())
            {
                key = md5.ComputeHash(key);
            }

            byte[] data = input, encdata = new byte[0];

            try
            {
                using (var ms = new MemoryStream())
                {
                    using (var aesProvider = new AesCryptoServiceProvider() { Key = key })
                    {
                        aesProvider.GenerateIV();

                        using (var cs = new CryptoStream(ms, aesProvider.CreateEncryptor(), CryptoStreamMode.Write))
                        {
                            ms.Write(aesProvider.IV, 0, aesProvider.IV.Length); // write first 16 bytes IV, followed by encrypted message
                            cs.Write(data, 0, data.Length);
                        }
                    }

                    encdata = ms.ToArray();
                }
            }
            catch
            {
            }
            return encdata;
        }
コード例 #8
0
ファイル: ExchangeAndTransfer.cs プロジェクト: xxy1991/cozy
        private async static Task<byte[]> AliceSendsData(string message)
        {
            Console.WriteLine("Alice send message {0}", message);
            byte[] rawData = Encoding.UTF8.GetBytes(message);
            byte[] encryptedData = null;

            using(var aliceAlgo = new ECDiffieHellmanCng(aliceKey))
            {
                using(CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.GenericPublicBlob))
                {
                    byte[] symmKey = aliceAlgo.DeriveKeyMaterial(bobPubKey);
                    Console.WriteLine("Alice create this symm key with Bobs public key information : {0}", Convert.ToBase64String(symmKey));
                    using(var aes = new AesCryptoServiceProvider())
                    {
                        aes.Key = symmKey;
                        aes.GenerateIV();
                        using(ICryptoTransform encryptor = aes.CreateEncryptor())
                        {
                            using(MemoryStream ms = new MemoryStream())
                            {
                                var cs = new CryptoStream(ms, encryptor,CryptoStreamMode.Write);
                                await ms.WriteAsync(aes.IV, 0, aes.IV.Length);
                                cs.Write(rawData, 0, rawData.Length);
                                cs.Close();
                                encryptedData = ms.ToArray();
                            }
                        }
                        aes.Clear();
                    }
                }
            }
            Console.WriteLine("Alice message is encrypted : {0}", Convert.ToBase64String(encryptedData));
            return encryptedData;
        }
コード例 #9
0
ファイル: CbcAes.cs プロジェクト: yurkova/cryptography_I
 protected override string EncryptByBlocks(byte[] key,
     List<byte> plainText)
 {
     var cipherText = new StringBuilder();
     if (plainText.Count % BlockSize == 0)
     {
         AddDummyBlock(plainText);
     }
     using (var aes = new AesCryptoServiceProvider())
     {
         aes.BlockSize = BlockSize * 8;
         aes.KeySize = KeySize * 8;
         aes.Padding = PaddingMode.None;
         aes.Key = key;
         aes.GenerateIV();
         cipherText.Append(BytesToHexString(aes.IV));
         using (var encr = aes.CreateEncryptor())
         {
             while (plainText.Count != 0)
             {
                 var block = DetachBlock(plainText);
                 if (block.Length < BlockSize)
                 {
                     block = CompleteBlock(block);
                 }
                 var encrypted = new byte[BlockSize];
                 encr.TransformBlock(block, 0, BlockSize, encrypted, 0);
                 cipherText.Append(BytesToHexString(encrypted));
                 aes.IV = encrypted;
             }
         }
     }
     return cipherText.ToString();
 }
コード例 #10
0
        /// <summary>
        /// AES Encryption
        /// </summary>
        public static string Encrypt(string clearText)
        {
            if (clearText == null) return null;
            // AesCryptoServiceProvider
            AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
            aes.BlockSize = 128;
            aes.KeySize = 128;

            aes.GenerateIV();
            aes.Key = Encoding.UTF8.GetBytes(AesKey);
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;

            // Convert string to byte array
            byte[] src = Encoding.Unicode.GetBytes(clearText);

            // encryption
            using (ICryptoTransform encrypt = aes.CreateEncryptor())
            {
                byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length);

                // Convert byte array to Base64 strings
                return Convert.ToBase64String(aes.IV) + Convert.ToBase64String(dest);
            }
        }
コード例 #11
0
 public static AesCryptoServiceProvider generateAESKey()
 {
     AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
     aes.KeySize = 256;
     aes.GenerateKey();
     aes.GenerateIV();
     
     return aes;
 }
コード例 #12
0
		// Create an object of type IV from a given object of type Key.
		// Usage of AesCryptoServiceProvider:
		// - create it 
		// - set its key size according the the size of the input Key
		// - use GenerateIV()
		public static IV createRandomIV(Key key)
		{
			using (var aes = new AesCryptoServiceProvider())
			{
				aes.KeySize = key.Format.BitSize.signed();
				// this should not be required?
				// aes.Key = key.Data;

				aes.GenerateIV();
				return new IV(aes.IV);
			}
		}
コード例 #13
0
ファイル: EncryptionHelper.cs プロジェクト: barbarossia/DIS
        /// <summary>
        /// Encrypt data with AES algorithm
        /// </summary>
        /// <param name="data"></param>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        public static byte[] AesEncrypt(byte[] data, out byte[] key, out byte[] iv)
        {
            if (data == null)
                throw new ArgumentNullException("No data to encrypt.");

            using (AesCryptoServiceProvider provider = new AesCryptoServiceProvider())
            {
                provider.GenerateKey();
                provider.GenerateIV();
                key = provider.Key;
                iv = provider.IV;
                return provider.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
            }
        }
コード例 #14
0
ファイル: Mobile_AES.cs プロジェクト: allanckw/GEMS-Web
        private static AesCryptoServiceProvider getProvider(byte[] keyPhrase)
        {
            AesCryptoServiceProvider result = new AesCryptoServiceProvider();
            result.BlockSize = 128;
            result.KeySize = 128;
            result.Mode = CipherMode.CBC;
            result.Padding = PaddingMode.PKCS7;

            result.GenerateIV();
            result.IV = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

            byte[] key = getKey(keyPhrase, result);
            result.Key = key;
            // result.IV = RealKey;
            return result;
        }
コード例 #15
0
ファイル: Security.cs プロジェクト: StevenThuriot/Vault.Core
        public static byte[] Encrypt(byte[] input, byte[] password, ushort saltSize, int iterations)
        {
            var salt = CreateSalt(saltSize);

            using (var aes = new AesCryptoServiceProvider())
            {
                aes.BlockSize = 128;
                aes.KeySize = 256;
                using (var key = new Rfc2898DeriveBytes(password, salt, iterations))
                {
                    aes.Key = key.GetBytes(16);
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;

                    aes.GenerateIV();

                    using (var memStream = new MemoryStream())
                    {
                        //While a byte would suffice, 
                        //we'll take the sure-thing and just use a ushort instead, this allows a key-length of 65535 tokens.
                        var bytes = new byte[sizeof(ushort)];
                        
                        fixed (void* b = bytes)
                            *((ushort*)b) = saltSize;
                        memStream.Write(bytes, 0, bytes.Length);

                        fixed (void* b = bytes)
                            *((ushort*)b) = (ushort)aes.IV.Length;
                        memStream.Write(bytes, 0, bytes.Length);

                        memStream.Write(salt, 0, salt.Length);
                        memStream.Write(aes.IV, 0, aes.IV.Length);

                        using (var encryptor = aes.CreateEncryptor())
                        using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
                        {
                            cryptoStream.Write(input, 0, input.Length);
                            cryptoStream.FlushFinalBlock();

                            var encrypted = memStream.ToArray();
                            return encrypted;
                        }
                    }
                }
            }
        }
コード例 #16
0
ファイル: CryptoUtils.cs プロジェクト: rsweeney21/Timecraft
 public static EncryptionResult AesEncrypt(byte[] data, byte[] key)
 {
     EncryptionResult result;
     using(var crypto = new AesCryptoServiceProvider {Key = key})
     {
         crypto.GenerateIV();
         result.IV = crypto.IV;
         var encryptor = crypto.CreateEncryptor();
         using (var stream = new MemoryStream())
         using (var cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Write))
         {
             cryptoStream.Write(data);
             cryptoStream.FlushFinalBlock();
             result.EncryptedData = stream.ToArray();
         }
     }
     return result;
 }
コード例 #17
0
        public TestSymmetricKeyProvider()
        {
            byte[] key;
            byte[] iv;

            using (var provider = new AesCryptoServiceProvider())
            {
                provider.GenerateIV();
                provider.GenerateKey();

                key = provider.Key;
                iv = provider.IV;

                provider.Clear();
            }

            _key = new TestSymmetricKey(key, iv);
        }
コード例 #18
0
        static void Main()
        {
            AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
            aes.GenerateKey();
            aes.GenerateIV();

            //Tworzenie CryptoTransform
            ICryptoTransform En = aes.CreateEncryptor();
            ICryptoTransform De = aes.CreateDecryptor();

            //Tworzenie potrzebnych zmiennych
            byte[] before = Encoding.UTF8.GetBytes("AES");
            byte[] after;
            byte[] end = new byte[1024];
            string result;

            //szyfrowanie
            using (MemoryStream mem = new MemoryStream())
            {
                using (CryptoStream crypt = new CryptoStream(mem, En, CryptoStreamMode.Write))
                {
                    crypt.Write(before, 0, before.Length);
                }
                after = mem.ToArray();
            }

            //deszyfracja
            using (MemoryStream mem = new MemoryStream(after))
            {
                int i;
                using (CryptoStream crypt = new CryptoStream(mem, De, CryptoStreamMode.Read))
                {
                    i = crypt.Read(end, 0, end.Length);
                }
                result = Encoding.UTF8.GetString(end, 0, i);
            }

            //wypisanie na ekran informacji.
            Console.WriteLine("Wiadomość: {0}", Encoding.UTF8.GetString(before));
            Console.WriteLine("Zaszyfrowana wiadomość: {0}", Encoding.UTF8.GetString(after));
            Console.WriteLine("Odszyfrowana wiadomość: {0}", result);
            Console.ReadKey();
        }
コード例 #19
0
        public byte[] EncryptToken(AuthenticationToken authenticationToken)
        {
            byte[] tokenBytes = authenticationToken.Serialize();

            var symmetricAlgorithm = new AesCryptoServiceProvider { Key = Convert.FromBase64String(authenticationKey) };
            symmetricAlgorithm.GenerateIV();
            var transform = symmetricAlgorithm.CreateEncryptor();

            using (var stream = new MemoryStream())
            {
                var writer = new BinaryWriter(stream);
                writer.Write(symmetricAlgorithm.IV.Length);
                writer.Write(symmetricAlgorithm.IV);
                using (var cryptoStream = new CryptoStream(stream, transform, CryptoStreamMode.Write))
                {
                    cryptoStream.Write(tokenBytes, 0, tokenBytes.Length);
                }
                return stream.ToArray();
            }
        }
コード例 #20
0
    public string Encrypt(string plainText, string password)
    {
        if (plainText == null)
        {
            throw new ArgumentNullException("plainText");
        }

        if (string.IsNullOrEmpty(password))
        {
            throw new ArgumentNullException("password");
        }

        // create instance of the AES crypto provider
        var aes = new AesCryptoServiceProvider();

        // generate a random IV will be used a salt value for generating key
        aes.GenerateIV();

        // use derive bytes to generate a key from the password and IV
        var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, aes.IV, Iterations);

        // generate a key from the password provided
        byte[] key = rfc2898DeriveBytes.GetBytes(16);

        // encrypt the plainText
        using (var memoryStream = new MemoryStream())
        using (var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(key, aes.IV), CryptoStreamMode.Write))
        {
            // write the salt first not encrypted
            memoryStream.Write(aes.IV, 0, aes.IV.Length);

            // convert the plain text string into a byte array
            byte[] bytes = Encoding.UTF8.GetBytes(plainText);

            // write the bytes into the crypto stream so that they are encrypted bytes
            cryptoStream.Write(bytes, 0, bytes.Length);
            cryptoStream.FlushFinalBlock();

            return Convert.ToBase64String(memoryStream.ToArray());
        }
    }
コード例 #21
0
ファイル: RsaAes.cs プロジェクト: yufeih/Nine.Common
        public static byte[] Encrypt(string publicKey, byte[] data)
        {
            using (var aes = new AesCryptoServiceProvider())
            {
                aes.GenerateKey();
                aes.GenerateIV();

                using (var encryptor = aes.CreateEncryptor())
                using (var ms = new MemoryStream())
                {
                    ms.Write(Rsa.Encrypt(publicKey, aes.IV), 0, 128);
                    ms.Write(Rsa.Encrypt(publicKey, aes.Key), 0, 128);

                    using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                    {
                        cs.Write(data, 0, data.Length);
                    }
                    return ms.ToArray();
                }
            }
        }
コード例 #22
0
ファイル: RsaAes.cs プロジェクト: yufeih/Nine.Common
        public static byte[] Encrypt(string publicKey, byte[] data)
        {
            using (var aes = new AesCryptoServiceProvider())
            {
                aes.GenerateKey();
                aes.GenerateIV();

                using (var encryptor = aes.CreateEncryptor())
                    using (var ms = new MemoryStream())
                    {
                        ms.Write(Rsa.Encrypt(publicKey, aes.IV), 0, 128);
                        ms.Write(Rsa.Encrypt(publicKey, aes.Key), 0, 128);

                        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                        {
                            cs.Write(data, 0, data.Length);
                        }
                        return(ms.ToArray());
                    }
            }
        }
コード例 #23
0
ファイル: Helpers.cs プロジェクト: WakeDown/ServiceCollector
        public string DecryptFile(byte[] data)
        {
            AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
            aes.GenerateIV();
            byte[] iv = aes.IV;
            aes.GenerateKey();
            byte[] key = aes.Key;
            ICryptoTransform cryptoTransform = aes.CreateEncryptor();
            MemoryStream memoryStream = new MemoryStream();
            CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write);
            StreamWriter streamWriter = new StreamWriter(cryptoStream);
            memoryStream = new MemoryStream(data);
            cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
            StreamReader streamReader = new StreamReader(cryptoStream);
            string decryptText = streamReader.ReadToEnd();
            streamWriter.Dispose();
            cryptoStream.Dispose();
            memoryStream.Dispose();

            return decryptText;
        }
コード例 #24
0
        private async Task<byte[]> AliceSendsDataAsync(string message)
        {
            WriteLine($"Alice sends message: {message}");
            byte[] rawData = Encoding.UTF8.GetBytes(message);
            byte[] encryptedData = null;

            using (var aliceAlgorithm = new ECDiffieHellmanCng(_aliceKey))
            using (CngKey bobPubKey = CngKey.Import(_bobPubKeyBlob,
                  CngKeyBlobFormat.EccPublicBlob))
            {
                byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey);
                WriteLine("Alice creates this symmetric key with " +
                      $"Bobs public key information: { Convert.ToBase64String(symmKey)}");

                using (var aes = new AesCryptoServiceProvider())
                {
                    aes.Key = symmKey;
                    aes.GenerateIV();
                    using (ICryptoTransform encryptor = aes.CreateEncryptor())
                    using (var ms = new MemoryStream())
                    {
                        // create CryptoStream and encrypt data to send
                        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                        {

                            // write initialization vector not encrypted
                            await ms.WriteAsync(aes.IV, 0, aes.IV.Length);
                            await cs.WriteAsync(rawData, 0, rawData.Length);
                        }
                        encryptedData = ms.ToArray();
                    }
                    aes.Clear();
                }
            }
            WriteLine($"Alice: message is encrypted: {Convert.ToBase64String(encryptedData)}"); ;
            WriteLine();
            return encryptedData;
        }
コード例 #25
0
ファイル: Crypto.cs プロジェクト: TheNilesh/encrypto
        private void initialize(string password,byte[] salt, byte[] iv)
        {
            AesCryptoServiceProvider csp=new AesCryptoServiceProvider();
               csp.Mode = CipherMode.CBC;
               csp.Padding = PaddingMode.PKCS7;
               var spec = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(password), salt, 65536);
               byte[] key = spec.GetBytes(16);
               csp.Key = key;

               if (iv == null)      //enc
               {
                   csp.GenerateIV();
                   this.IV = csp.IV;
                   ict = csp.CreateEncryptor();

               }
               else
               {
                   csp.IV = iv;
                   ict = csp.CreateDecryptor();
                   this.IV = iv;
               }
        }
コード例 #26
0
        public TestSymmetricKeyProvider(params string[] ids)
        {
            _keys = new Dictionary<string, TestSymmetricKey>();

            foreach (var id in ids.Concat(new[] {"default"}).Distinct())
            {
                byte[] key;
                byte[] iv;

                using (var provider = new AesCryptoServiceProvider())
                {
                    provider.GenerateIV();
                    provider.GenerateKey();

                    key = provider.Key;
                    iv = provider.IV;

                    provider.Clear();
                }

                _keys.Add(id, new TestSymmetricKey(key, iv));
            }
        }
コード例 #27
0
        /// <summary>
        /// データを暗号化し、ファイルに出力します。
        /// </summary>
        /// <param name="ms">暗号化したいメモリストリーム</param>
        /// <param name="outfilepath">出力ファイルの名前</param>
        public static void EncryptionData(MemoryStream ms, string outfilepath)
        {
            //AesCryptoServiceProviderオブジェクトの作成
            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider()) {
                aes.BlockSize = 128;						//ブロックサイズ(128bit)
                aes.KeySize = 128;							//キー最大長(128bit)
                aes.Mode = CipherMode.CBC;					//CBCモード
                aes.Padding = PaddingMode.PKCS7;			//パディングモード
                aes.GenerateIV();
                byte[] bytesIV = aes.IV;					//初期化ベクトルの設定と取得(ブロックサイズと同サイズ=128bit)
                aes.Key = AESTransformBytes(PASSWORD);	//キーの設定
                ICryptoTransform encrypt = aes.CreateEncryptor();	//AES暗号化オブジェクトの作成

                //FileStreamの生成
                using (System.IO.FileStream outfs = new System.IO.FileStream(outfilepath, System.IO.FileMode.Create, System.IO.FileAccess.Write)) {
                    outfs.Write(bytesIV, 0, 16);	//IVを先頭に書き込む(128bit=16bytes)

                    //CryptoStreamの作成
                    using (CryptoStream cs = new CryptoStream(
                        outfs, encrypt, CryptoStreamMode.Write)) {
                        //暗号化データを書き出していく
                        byte[] buffer = new byte[4096];//[2048];//byte[1024]
                        int length;

                        while ((length = ms.Read(buffer, 0, buffer.Length)) > 0) {
                            cs.Write(buffer, 0, length);// bufferは87くらいまでしか使われてない
                        }
                    }
                }
            }
        }
コード例 #28
0
ファイル: Helpers.cs プロジェクト: WakeDown/ServiceCollector
        public byte[] EncryptFile(string text)
        {
            AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
            aes.GenerateIV();
            byte[] iv = aes.IV;
            aes.GenerateKey();
            byte[] key = aes.Key;
            ICryptoTransform cryptoTransform = aes.CreateEncryptor();
            MemoryStream memoryStream = new MemoryStream();
            CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write);
            StreamWriter streamWriter = new StreamWriter(cryptoStream);
            streamWriter.Write(text);
            byte[] enryptText = memoryStream.ToArray();
            streamWriter.Dispose();
            cryptoStream.Dispose();
            memoryStream.Dispose();

            return enryptText;
        }
コード例 #29
0
ファイル: Cryptography.cs プロジェクト: bkboggy/AesCrypto
        /// <summary>
        /// Encrypts string to an array of bytes using an AesCryptoServiceProvider.
        /// </summary>
        /// <param name="plainText">Input value to be necrypted.</param>
        /// <param name="Key">Key used in the encryption process.</param>
        /// <returns>An ecnrypted byte array.</returns>
        public static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key)
        {
            // Check arguments.
            if (string.IsNullOrWhiteSpace(plainText))
            {
                throw new ArgumentNullException("plainText");
            }
            if (Key == null || Key.Length <= 0)
            {
                throw new ArgumentNullException("Key");
            }

            // Byte array used to store the encrypted data.
            byte[] encrypted;

            // Create an AesCryptoServiceProvider object with the specified key and
            // a random IV.
            using (var aesAlg = new AesCryptoServiceProvider())
            {
                aesAlg.Key = Key;
                aesAlg.GenerateIV();

                // Create a decrytor to perform the stream transform.
                using (var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV))
                {
                    // Create the streams used for encryption.
                    using (var msEncrypt = new MemoryStream())
                    {
                        // Write out IV.
                        msEncrypt.Write(aesAlg.IV, 0, 16);

                        using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                        {
                            using (var swEncrypt = new StreamWriter(csEncrypt))
                            {
                                //Write all data to the stream.
                                swEncrypt.Write(plainText);
                            }
                            encrypted = msEncrypt.ToArray();
                        }
                    }
                }
            }
            return encrypted;
        }
コード例 #30
0
 public static byte[] getInitializationVector()
 {
     AesCryptoServiceProvider myAes = new AesCryptoServiceProvider();
     myAes.GenerateIV();
     return myAes.IV;
 }
コード例 #31
0
ファイル: DataMotion.cs プロジェクト: DataMotionInc/DMWeb
 public ResponseModel Provision(CompanyModel companyModel, string UserName, string PlatformCode, Command Command, string Email)
 {
     //Generate IV
     AesCryptoServiceProvider cryptoProvider = new AesCryptoServiceProvider();
     cryptoProvider.KeySize = 256;
     cryptoProvider.GenerateIV();
     string IV = Convert.ToBase64String(cryptoProvider.IV);
     //Encrypt Model
     byte[] data = Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(companyModel));
     byte[] key = Convert.FromBase64String(provisionerKey);
     string hash = Convert.ToBase64String(new HMACSHA512(key).ComputeHash(data));
     string data2 = Encrypt(key, Convert.FromBase64String(IV), Newtonsoft.Json.JsonConvert.SerializeObject(companyModel));
     //Construct the request model
     RequestModel requestModel = new RequestModel
     {
         UserName = UserName,
         PlatformCode = PlatformCode,
         Command = Command,
         IV = IV,
         Data = data2,
         Hash = hash
     };
     var req = new WebClient();
     req.BaseAddress = "https://provisioning.datamotion.com:8888";
     req.Headers.Clear();
     req.Headers.Add("Accept", "application/json");
     req.Headers.Add(Headers.Email, Email);
     req.Headers.Add(Headers.Iv, IV);
     try
     {
         var request = req.UploadData("https://provisioning.datamotion.com:8888", Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(requestModel)));
         ResponseModel response = JsonConvert.DeserializeObject<ResponseModel>(Encoding.UTF8.GetString(request));
         response.Data = Decrypt(key, Convert.FromBase64String(response.IV), response.Data);
         return response;
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }