Windows中應用C#為文件夾和文件編寫暗碼鎖的示例分享

Windows中應用C#為文件夾和文件編寫暗碼鎖的示例分享。本站提示廣大學習愛好者：（Windows中應用C#為文件夾和文件編寫暗碼鎖的示例分享）文章只能為提供參考，不一定能成為您想要的結果。以下是Windows中應用C#為文件夾和文件編寫暗碼鎖的示例分享正文

C#文件夾加鎖小對象
用C#說話完成一個文件夾鎖的法式，網上相似的“xxx文件夾xxx”軟件許多，然則根本上都是C/C++說話完成的，且都沒有供給源碼（這個可以懂得，究竟是加密法式，不該該洩漏源碼）。

法式的根本道理是：用C#說話重定名文件夾，經由過程重定名使之成為windows平安文件的類標識符。詳細的辦法是為文件夾添加拓展名“.{2559a1f2-21d7-11d4-bdaf-00c04f60b9f0}”

（.{2559a1f2-21d7-11d4-bdaf-00c04f60b9f0}是windows平安文件的類標識符），這時候文件夾的圖標就會釀成一把鎖，如許文件夾就被加鎖了。

法式的主界面異常簡練，截圖以下：

法式中加密解密文件夾的焦點代碼以下：

    private void btnBrowseFolder_Click(object sender, EventArgs e)
    {
      
      status = lockType;//
      

      if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
      {
        DirectoryInfo d = new DirectoryInfo(folderBrowserDialog1.SelectedPath);
        string selectedpath = d.Parent.FullName + d.Name;
        if (folderBrowserDialog1.SelectedPath.LastIndexOf(".{") == -1)//經由過程文件夾稱號，斷定加密
        {          
          SetPwd(folderBrowserDialog1.SelectedPath);
          if (!d.Root.Equals(d.Parent.FullName))
          {            
              d.MoveTo(d.Parent.FullName + "\\" + d.Name + status);//文件夾重定名
          }
          else d.MoveTo(d.Parent.FullName + d.Name + status);
          txtFolderPath.Text = folderBrowserDialog1.SelectedPath;
          
        }
        else//解密文件夾
        {
          status = GetStatus(status);
          bool s = CheckPwd();
          if (s)
          {
            File.Delete(folderBrowserDialog1.SelectedPath + "\\key.xml");
            string path = folderBrowserDialog1.SelectedPath.Substring(0, folderBrowserDialog1.SelectedPath.LastIndexOf("."));
            d.MoveTo(path);
            txtFolderPath.Text = path;
            
          }
        }
      }
    }

法式的運轉後果以下：

以加密D盤上面的test文件夾為例，成果以下:

起首經由過程folderBrowserDialog選擇響應的文件夾

輸出暗碼，加鎖

後果以下：

此時雙擊文件夾曾經沒法翻開。

選擇加密後的test文件夾，輸出加密時輸出的暗碼，可解鎖。

test文件夾曾經解密

加密解密文件小對象

下面分享了一個文件夾加密小對象，該對象是操作文件夾稱號的辦法完成文件夾的普通加密，文件夾中的文件（視頻、圖片等）都原封不動的保留在那邊。

在網上搜刮相干文件加密的法式，發明給出的根本都是針對“字符創”、“文本”的加密與解密。對視頻文件、圖片等普通文件的加密解密法式少之又少，所以我們上面再來完成一個對普通文件停止加密的小對象。

法式的重要功效是：用戶經由過程文件選擇框選摘要加密的文件-》輸出暗碼停止加密；選擇加密後的文件，輸出暗碼停止解密。

法式的主界面以下：

三個按鈕的Click事宜處置法式以下：

    private void btnSelectFile_Click(object sender, EventArgs e)
    {
      if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
      {
        txtFileName.Text = openFileDialog1.FileName ;
      }
    }

    private void btnEncryptFile_Click(object sender, EventArgs e)
    {
      string inFile=txtFileName.Text;
      string outFile = inFile + ".dat";
      string password=txtPassword.Text ;
      DESFile.DESFileClass.EncryptFile(inFile, outFile, password);//加密文件
      //刪除加密前的文件
      File.Delete(inFile);
      txtFileName.Text = string.Empty;
      MessageBox.Show("加密勝利");
    }

    private void btnDecryptFile_Click(object sender, EventArgs e)
    {
      string inFile = txtFileName.Text;
      string outFile = inFile.Substring(0,inFile.Length - 4);
      string password = txtPassword.Text;
      DESFile.DESFileClass.DecryptFile (inFile, outFile, password);//解密文件
      //刪除解密前的文件
      File.Delete(inFile);
      txtFileName.Text = string.Empty;
      MessageBox.Show("解密勝利");
    }

加密解密的Help文件源碼以下：

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace DESFile
{
  /// <summary>
  /// 異常處置類
  /// </summary>
  public class CryptoHelpException : ApplicationException
  {
    public CryptoHelpException(string msg) : base(msg) { }
  }

  /// <summary>
  /// CryptHelp
  /// </summary>
  public class DESFileClass
  {
    private const ulong FC_TAG = 0xFC010203040506CF;

    private const int BUFFER_SIZE = 128 * 1024;

    /// <summary>
    /// 磨練兩個Byte數組能否雷同
    /// </summary>
    /// <param name="b1">Byte數組</param>
    /// <param name="b2">Byte數組</param>
    /// <returns>true－相等</returns>
    private static bool CheckByteArrays(byte[] b1, byte[] b2)
    {
      if (b1.Length == b2.Length)
      {
        for (int i = 0; i < b1.Length; ++i)
        {
          if (b1[i] != b2[i])
            return false;
        }
        return true;
      }
      return false;
    }

    /// <summary>
    /// 創立DebugLZQ ,http://www.cnblogs.com/DebugLZQ
    /// </summary>
    /// <param name="password">暗碼</param>
    /// <param name="salt"></param>
    /// <returns>加密對象</returns>
    private static SymmetricAlgorithm CreateRijndael(string password, byte[] salt)
    {
      PasswordDeriveBytes pdb = new PasswordDeriveBytes(password, salt, "SHA256", 1000);

      SymmetricAlgorithm sma = Rijndael.Create();
      sma.KeySize = 256;
      sma.Key = pdb.GetBytes(32);
      sma.Padding = PaddingMode.PKCS7;
      return sma;
    }

    /// <summary>
    /// 加密文件隨機數生成
    /// </summary>
    private static RandomNumberGenerator rand = new RNGCryptoServiceProvider();

    /// <summary>
    /// 生成指定長度的隨機Byte數組
    /// </summary>
    /// <param name="count">Byte數組長度</param>
    /// <returns>隨機Byte數組</returns>
    private static byte[] GenerateRandomBytes(int count)
    {
      byte[] bytes = new byte[count];
      rand.GetBytes(bytes);
      return bytes;
    }

    /// <summary>
    /// 加密文件
    /// </summary>
    /// <param name="inFile">待加密文件</param>
    /// <param name="outFile">加密後輸出文件</param>
    /// <param name="password">加密暗碼</param>
    public static void EncryptFile(string inFile, string outFile, string password)
    {
      using (FileStream fin = File.OpenRead(inFile),
        fout = File.OpenWrite(outFile))
      {
        long lSize = fin.Length; // 輸出文件長度
        int size = (int)lSize;
        byte[] bytes = new byte[BUFFER_SIZE]; // 緩存
        int read = -1; // 輸出文件讀取數目
        int value = 0;

        // 獲得IV和salt
        byte[] IV = GenerateRandomBytes(16);
        byte[] salt = GenerateRandomBytes(16);

        // 創立加密對象
        SymmetricAlgorithm sma = DESFileClass.CreateRijndael(password, salt);
        sma.IV = IV;

        // 在輸入文件開端部門寫入IV和salt
        fout.Write(IV, 0, IV.Length);
        fout.Write(salt, 0, salt.Length);

        // 創立散列加密
        HashAlgorithm hasher = SHA256.Create();
        using (CryptoStream cout = new CryptoStream(fout, sma.CreateEncryptor(), CryptoStreamMode.Write),
          chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write))
        {
          BinaryWriter bw = new BinaryWriter(cout);
          bw.Write(lSize);

          bw.Write(FC_TAG);

          // 讀寫字節塊到加密流緩沖區
          while ((read = fin.Read(bytes, 0, bytes.Length)) != 0)
          {
            cout.Write(bytes, 0, read);
            chash.Write(bytes, 0, read);
            value += read;
          }
          // 封閉加密流
          chash.Flush();
          chash.Close();

          // 讀取散列
          byte[] hash = hasher.Hash;

          // 輸出文件寫入散列
          cout.Write(hash, 0, hash.Length);

          // 封閉文件流
          cout.Flush();
          cout.Close();
        }
      }
    }

    /// <summary>
    /// 解密文件
    /// </summary>
    /// <param name="inFile">待解密文件</param>
    /// <param name="outFile">解密後輸入文件</param>
    /// <param name="password">解密暗碼</param>
    public static void DecryptFile(string inFile, string outFile, string password)
    {
      // 創立翻開文件流
      using (FileStream fin = File.OpenRead(inFile),
        fout = File.OpenWrite(outFile))
      {
        int size = (int)fin.Length;
        byte[] bytes = new byte[BUFFER_SIZE];
        int read = -1;
        int value = 0;
        int outValue = 0;

        byte[] IV = new byte[16];
        fin.Read(IV, 0, 16);
        byte[] salt = new byte[16];
        fin.Read(salt, 0, 16);

        SymmetricAlgorithm sma = DESFileClass.CreateRijndael(password, salt);
        sma.IV = IV;

        value = 32;
        long lSize = -1;

        // 創立散列對象, 校驗文件
        HashAlgorithm hasher = SHA256.Create();

        using (CryptoStream cin = new CryptoStream(fin, sma.CreateDecryptor(), CryptoStreamMode.Read),
          chash = new CryptoStream(Stream.Null, hasher, CryptoStreamMode.Write))
        {
          // 讀取文件長度
          BinaryReader br = new BinaryReader(cin);
          lSize = br.ReadInt64();
          ulong tag = br.ReadUInt64();

          if (FC_TAG != tag)
            throw new CryptoHelpException("文件被損壞");

          long numReads = lSize / BUFFER_SIZE;

          long slack = (long)lSize % BUFFER_SIZE;

          for (int i = 0; i < numReads; ++i)
          {
            read = cin.Read(bytes, 0, bytes.Length);
            fout.Write(bytes, 0, read);
            chash.Write(bytes, 0, read);
            value += read;
            outValue += read;
          }

          if (slack > 0)
          {
            read = cin.Read(bytes, 0, (int)slack);
            fout.Write(bytes, 0, read);
            chash.Write(bytes, 0, read);
            value += read;
            outValue += read;
          }

          chash.Flush();
          chash.Close();

          fout.Flush();
          fout.Close();

          byte[] curHash = hasher.Hash;

          // 獲得比擬和舊的散列對象
          byte[] oldHash = new byte[hasher.HashSize / 8];
          read = cin.Read(oldHash, 0, oldHash.Length);
          if ((oldHash.Length != read) || (!CheckByteArrays(oldHash, curHash)))
            throw new CryptoHelpException("文件被損壞");
        }

        if (outValue != lSize)
          throw new CryptoHelpException("文件年夜小不婚配");
      }
    }
  }
}

加密/解密成果：

以加密D盤下的1.avi為例，加密後的文件為1.avi.dat，即便重定名回1.avi文件仍然沒法翻開（文件被加密）。

輸出暗碼停止解密後，文件恢復解密，可以順遂翻開~