using System;
using System.IO;
using System.Security.Cryptography;

namespace ConsoleApp_SymmetricalEncryption
{
class Program
    {
static void Main(string[] args)
        {
            SymmetricalEncryption ss = new SymmetricalEncryption();

            ss.EncryptFile(@"C:\error.txt", @"C:\error_EncryptFile.txt", ss.Key);
            Console.WriteLine("加密成功！");
            Console.ReadKey();
            ss.DecryptFile(@"C:\error_EncryptFile.txt", @"C:\error_DecryptFile.txt", ss.Key);
            Console.WriteLine("解密成功！");
            Console.ReadKey();
        }
    }

/// <summary>
/// 对文件使用对称加密算法
/// </summary>
public class SymmetricalEncryption
    {
/* 对称加密： 
         * 需要发送者和接收者协定一个密钥K，K可以是一个密钥对，但必须是加密密钥和解密密钥之间能够互相推算出来的。
         * 常用的对称加密算法中，加密解密共享一个密钥。
         * 本例中使用的是同一个密钥；
         * 
         * 非对称加密：
         * 有一个密钥对，分别为 公钥、私钥(公钥用来加密，私钥用来解密)
         * 私钥永远不需要传递给对方；
         *         
         * 优缺点比较：
         * 非对称加密算法复杂，导致加解密速度慢，只适合与数据量小的场合。
         * 对称加密解密效率高，系统开销小，适合金星大数据量的加解密。(大文件一般适合使用对称加密)         
         */

/// <summary>
/// 随机产生的密钥(也可以自己指定)
/// 【注意：对称加密算法 加密解密用的Key值是相同的(非对称加密才分：公钥和私钥)】
/// </summary>
public string Key = Guid.NewGuid().ToString().Replace("-", "").ToUpper() + Guid.NewGuid().ToString().Replace("-", "").ToUpper();

/// <summary>
/// 缓冲区大小
/// </summary>
private int bufferSize = 128 * 1024;

/// <summary>
/// 密钥salt
/// </summary>
private byte[] salt = { 134, 216, 7, 36, 88, 164, 91, 227, 174, 76, 191, 197, 192, 154, 200, 248 };
//salt用来防止穷举暴力破解(salt是在密钥导出之前在密码末尾引入的随机字节，它使得这类攻击变得非常困难)

/// <summary>
/// 初始化向量
/// </summary>
private byte[] iv = { 134, 216, 7, 36, 88, 164, 91, 227, 174, 76, 191, 197, 192, 154, 200, 248 };
//初始化向量iv起到的也是增强破解难度的作用

/// <summary>
/// 初始化 并返回对称加密算法
/// </summary>
/// <param name="argKey"></param>
/// <param name="argSalt"></param>
/// <returns></returns>
private SymmetricAlgorithm CreateRijindael(string argKey, byte[] argSalt)
        {
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(argKey, argSalt, "SHA256", 1000);
            SymmetricAlgorithm sma = Rijndael.Create();
            sma.KeySize = 256;
            sma.Key = pdb.GetBytes(32);
            sma.Padding = PaddingMode.PKCS7;
return sma;
        }

/// <summary>
/// 加密文件
/// </summary>
/// <param name="argInFile">输入文件</param>
/// <param name="argOutFile">输出加密后的文件</param>
/// <param name="argKey">加密用的Key</param>
public void EncryptFile(string argInFile, string argOutFile, string argKey)
        {
using (FileStream inFileStream = File.OpenRead(argInFile),
                    outFileStream = File.Open(argOutFile, FileMode.OpenOrCreate))
using (SymmetricAlgorithm algorithm = CreateRijindael(argKey, salt))
            {
                algorithm.IV = iv;
using (CryptoStream cryptoStream = new CryptoStream(outFileStream, algorithm.CreateEncryptor(),
                        CryptoStreamMode.Write))
                {
byte[] bytes = new byte[bufferSize];
int readSize = -1;
while ((readSize = inFileStream.Read(bytes, 0, bytes.Length)) != 0)
                    {
                        cryptoStream.Write(bytes, 0, readSize);
                    }
                    cryptoStream.Flush();
                }
            }
        }

/// <summary>
/// 解密文件
/// </summary>
/// <param name="argInFile">输入待解密的文件</param>
/// <param name="argOutFile">输出解密后的文件</param>
/// <param name="argKey">加密用的Key</param>
public void DecryptFile(string argInFile, string argOutFile, string argKey)
        {
try
            {
using (FileStream inFileStream = File.OpenRead(argInFile), outFileStream = File.OpenWrite(argOutFile))
using (SymmetricAlgorithm algorithm = CreateRijindael(argKey, salt))
                {
                    algorithm.IV = iv;
using (CryptoStream cryptoStream = new CryptoStream(inFileStream, algorithm.CreateDecryptor(),
                            CryptoStreamMode.Read))
                    {
byte[] bytes = new byte[bufferSize];
int readSize = -1;
int numReads = (int)(inFileStream.Length / bufferSize);
int slack = (int)(inFileStream.Length % bufferSize);
for (int i = 0; i < numReads; ++i)
                        {
                            readSize = cryptoStream.Read(bytes, 0, bytes.Length);
                            outFileStream.Write(bytes, 0, readSize);
                        }
if (slack > 0)
                        {
                            readSize = cryptoStream.Read(bytes, 0, (int)slack);
                            outFileStream.Write(bytes, 0, readSize);
                        }
                        outFileStream.Flush();
                    }
                }
            }
catch (Exception ex)
            { 
throw new Exception("解密失败：" + ex.Message);//可能是密钥输入的不正确，或者文件被修改过
            }
        }

    }
}