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文件依然无法打开(文件被加密)。

输入密码进行解密后,文件恢复解密,可以顺利打开~

时间: 2016-03-06

如何使用C#读写锁ReaderWriterLockSlim

读写锁的概念很简单,允许多个线程同时获取读锁,但同一时间只允许一个线程获得写锁,因此也称作共享-独占锁.在C#中,推荐使用ReaderWriterLockSlim类来完成读写锁的功能. 某些场合下,对一个对象的读取次数远远大于修改次数,如果只是简单的用lock方式加锁,则会影响读取的效率.而如果采用读写锁,则多个线程可以同时读取该对象,只有等到对象被写入锁占用的时候,才会阻塞. 简单的说,当某个线程进入读取模式时,此时其他线程依然能进入读取模式,假设此时一个线程要进入写入模式,那么他不得不被阻塞

C#多线程编程中的锁系统(二)

上章主要讲排他锁的直接使用方式.但实际当中全部都用锁又太浪费了,或者排他锁粒度太大了. 这一次我们说说升级锁和原子操作. 目录 1:volatile 2:  Interlocked 3:ReaderWriterLockSlim 4:总结 一:volatile 简单来说: volatile关键字是告诉c#编译器和JIT编译器,不对volatile标记的字段做任何的缓存.确保字段读写都是原子操作,最新值. 这不就是锁吗?   其这货它根本不是锁, 它的原子操作是基于CPU本身的,非阻塞的. 因为32

C#检查键盘大小写锁定状态的方法

本文实例讲述了C#检查键盘大小写锁定状态的方法.分享给大家供大家参考.具体分析如下: 1.命名空间: using System.Runtime.InteropServices; 2.导入方法 [DllImport("user32.dll", EntryPoint = "GetKeyboardState")] public static extern int GetKeyboardState(byte[] pbKeyState); 3.大小写状态 public sta

C#解决SQlite并发异常问题的方法(使用读写锁)

本文实例讲述了C#解决SQlite并发异常问题的方法.分享给大家供大家参考,具体如下: 使用C#访问sqlite时,常会遇到多线程并发导致SQLITE数据库损坏的问题. SQLite是文件级别的数据库,其锁也是文件级别的:多个线程可以同时读,但是同时只能有一个线程写.Android提供了SqliteOpenHelper类,加入Java的锁机制以便调用.但在C#中未提供类似功能. 作者利用读写锁(ReaderWriterLock),达到了多线程安全访问的目标. using System; usin

C#中lock死锁实例教程

在c#中有个关键字lock,它的作用是锁定某一代码块,让同一时间只有一个线程访问该代码块,本文就来谈谈lock关键字的原理和其中应注意的几个问题: lock的使用原型是: lock(X) { //需要锁定的代码.... } 首先要明白为什么上面这段话能够锁定代码,其中的奥妙就是X这个对象,事实上X是任意一种引用类型,它在这儿起的作用就是任何线程执行到lock(X)时候,X需要独享才能运行下面的代码,若假定现在有3个线程A,B,C都执行到了lock(X)而ABC因为此时都占有X,这时ABC就要停下

C#多线程编程中的锁系统基本用法

平常在多线程开发中,总避免不了线程同步.本篇就对net多线程中的锁系统做个简单描述. 目录 一:lock.Monitor      1:基础.      2: 作用域.      3:字符串锁.      4:monitor使用 二:mutex 三:Semaphore 四:总结 一:lock.Monitor 1:基础 Lock是Monitor语法糖简化写法.Lock在IL会生成Monitor. 复制代码 代码如下: //======Example 1=====             strin

C#实现将程序锁定到Win7任务栏的方法

本文实例讲述了C#实现将程序锁定到Win7任务栏的方法.分享给大家供大家参考.具体实现方法如下: Win7Taskbar类: using System; using System.Collections.Generic; using System.Text; using Shell32; using System.IO; namespace TestWin7Taskbar { class Win7Taskbar { public static bool LockApp(bool isLock,

C#多线程编程中的锁系统(三)

本章主要说下基于内核模式构造的线程同步方式,事件,信号量. 目录 一:理论 二:WaitHandle 三:AutoResetEvent 四:ManualResetEvent 五:总结 一:理论 我们晓得线程同步可分为,用户模式构造和内核模式构造. 内核模式构造:是由windows系统本身使用,内核对象进行调度协助的.内核对象是系统地址空间中的一个内存块,由系统创建维护. 内核对象为内核所拥有,而不为进程所拥有,所以不同进程可以访问同一个内核对象, 如进程,线程,作业,事件,文件,信号量,互斥量等

C#多线程中如何运用互斥锁Mutex

互斥锁(Mutex) 互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它. 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况 函数: //创建一个处于未获取状态的互斥锁 Public Mutex(): //如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态 Public Mutex(bool owned): 如果要获取一个互斥锁.应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类 它处于等到状态直至所调用

C#多线程编程中的锁系统(四):自旋锁

目录 一:基础 二:自旋锁示例 三:SpinLock 四:继续SpinLock 五:总结 一:基础 内核锁:基于内核对象构造的锁机制,就是通常说的内核构造模式.用户模式构造和内核模式构造 优点:cpu利用最大化.它发现资源被锁住,请求就排队等候.线程切换到别处干活,直到接受到可用信号,线程再切回来继续处理请求. 缺点:托管代码->用户模式代码->内核代码损耗.线程上下文切换损耗. 在锁的时间比较短时,系统频繁忙于休眠.切换,是个很大的性能损耗. 自旋锁:原子操作+自循环.通常说的用户构造模式.

Java多线程编程中synchronized关键字的基础用法讲解

多线程编程中,最关键.最关心的问题应该就是同步问题,这是一个难点,也是核心. 从jdk最早的版本的synchronized.volatile,到jdk 1.5中提供的java.util.concurrent.locks包中的Lock接口(实现有ReadLock,WriteLock,ReentrantLock),多线程的实现也是一步步走向成熟化.   同步,它是通过什么机制来控制的呢?第一反应就是锁,这个在学习操作系统与数据库的时候,应该都已经接触到了.在Java的多线程程序中,当多个程序竞争同一

详解Java多线程编程中互斥锁ReentrantLock类的用法

0.关于互斥锁 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是

详解Java多线程编程中的线程同步方法

1.多线程的同步: 1.1.同步机制: 在多线程中,可能有多个线程试图访问一个有限的资源,必须预防这种情况的发生.所以引入了同步机制:在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问. 1.2.共享成员变量的例子: 成员变量与局部变量: 成员变量: 如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作,这多个线程是共享一个成员变量的. 局部变量: 如果一个变量是局部变量,那么多个线程对同一个对象进行操作,每个线程都会有一个该局部变量的拷贝.他们

Java多线程编程中synchronized线程同步的教程

0.关于线程同步 (1)为什么需要同步多线程? 线程的同步是指让多个运行的线程在一起良好地协作,达到让多线程按要求合理地占用释放资源.我们采用Java中的同步代码块和同步方法达到这样的目的.比如这样的解决多线程无固定序执行的问题: public class TwoThreadTest { public static void main(String[] args) { Thread th1= new MyThread1(); Thread th2= new MyThread2(); th1.st

举例解析Java多线程编程中需要注意的一些关键点

1. 同步方法或同步代码块? 您可能偶尔会思考是否要同步化这个方法调用,还是只同步化该方法的线程安全子集.在这些情况下,知道 Java 编译器何时将源代码转化为字节代码会很有用,它处理同步方法和同步代码块的方式完全不同. 当 JVM 执行一个同步方法时,执行中的线程识别该方法的 method_info 结构是否有 ACC_SYNCHRONIZED 标记设置,然后它自动获取对象的锁,调用方法,最后释放锁.如果有异常发生,线程自动释放锁. 另一方面,同步化一个方法块会越过 JVM 对获取对象锁和异常

python多线程编程中的join函数使用心得

今天去辛集买箱包,下午挺晚才回来,又是恶心又是头痛.恶心是因为早上吃坏东西+晕车+回来时看到车祸现场,头痛大概是烈日和空调混合刺激而成.没有时间没有精神没有力气学习了,这篇博客就说说python中一个小小函数. 由于坑爹的学校坑爷的专业,多线程编程老师从来没教过,多线程的概念也是教的稀里糊涂,本人python也是菜鸟级别,所以遇到多线程的编程就傻眼了,别人用的顺手的join函数我却偏偏理解不来.早上在去辛集的路上想这个问题想到恶心,回来后继续写代码测试,终于有些理解了(python官方的英文解释