C#文件安全管理解析

    在实际的项目开发中,我们经常需要使用到文件的I/O操作,主要包含对文件的增改删查等操作,这些基本的操作我们都是很熟悉,但是较少的人去考虑文件的安全和操作的管理等方面,例如文件的访问权限管理,文件数据的彻底删除和数据的恢复等等,这一系列的操作需要我们对.NET的相关知识有一个深刻的学习。

    在本文章主要介绍文件和目录的一些基本操作,以及文件目录的权限和安全设置的相关内容。

一.DotNet文件目录常用操作:

    提到文件的I/O操作,这个对于每一个开发者来说都不是陌生的事,因为这些操作是我们在项目开发过程中经常使用到的一些操作。那么在.NET中操作文件的类在System.IO命名空间下,一下介绍一下常见的I/O操作类:

        DiveInfo:提供了对逻辑磁盘的基本信息访问的途径。(只能查看信息,不能做任何修改。)

        System.Environment:用来枚举驱动器。(不能获取驱动器的属性)

        System.Management:.NET针对WMI调用。

        Directory和DircetoryInfo:用于操作目录。(前者为静态类,后者则须在实例化后调用,功能上相同)

        File和FileInfo:用于操作文件。(前者为静态类,后者须实例化后调用,功能上相同)

    以上介绍了一些文件的基本操作类,本次主要讲解目录和文件操作,一下给出文件和目录操作的一些基本方法:

   1.文件常规操作:

      (1).文件读写操作:
        /// <summary>
        /// 写文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="content">文件内容</param>
        /// <param name="encoding">指定文件编码</param>
        protected void Write_Txt(string fileName, string content, string encoding)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                throw new ArgumentNullException(fileName);
            }
            if (string.IsNullOrEmpty(content))
            {
                throw new ArgumentNullException(content);
            }
            if (string.IsNullOrEmpty(encoding))
            {
                throw new ArgumentNullException(encoding);
            }
            var code = Encoding.GetEncoding(encoding);
            var htmlfilename = HttpContext.Current.Server.MapPath("Precious\\" + fileName + ".txt");
            var str = content;
            var sw = StreamWriter.Null;
            try
            {
                using (sw = new StreamWriter(htmlfilename, false, code))
                {
                    sw.Write(str);
                    sw.Flush();
                }
            }
            catch (IOException ioex)
            {
                throw new IOException(ioex.Message);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                sw.Close();
            }
        }

        /// <summary>
        /// 读文件
        /// </summary>
        /// <param name="filename">文件路径</param>
        /// <param name="encoding">文件编码</param>
        /// <returns></returns>
        protected string Read_Txt(string filename, string encoding)
        {
            if (string.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException(filename);
            }
            if (string.IsNullOrEmpty(encoding))
            {
                throw new ArgumentNullException(encoding);
            }
            var code = Encoding.GetEncoding(encoding);
            var temp = HttpContext.Current.Server.MapPath("Precious\\" + filename + ".txt");
            var str = string.Empty;
            if (!System.IO.File.Exists(temp)) return str;
            var sr = StreamReader.Null;
            try
            {
                using (sr = new StreamReader(temp, code))
                {
                    str = sr.ReadToEnd();
                }
            }
            catch (IOException ioex)
            {
                throw new IOException(ioex.Message);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                sr.Close();
            }
            return str;
        }
    (2).文件附加操作:
        /// <summary>
        /// 拷贝文件
        /// </summary>
        /// <param name="orignFile">原始文件</param>
        /// <param name="newFile">新文件路径</param>
        public static void FileCoppy(string orignFile, string newFile)
        {
            if (string.IsNullOrEmpty(orignFile))
            {
                throw new ArgumentException(orignFile);
            }
            if (string.IsNullOrEmpty(newFile))
            {
                throw new ArgumentException(newFile);
            }
            System.IO.File.Copy(orignFile, newFile, true);
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="path">路径</param>
        public static void FileDel(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException(path);
            }
            System.IO.File.Delete(path);
        }

        /// <summary>
        /// 移动文件
        /// </summary>
        /// <param name="orignFile">原始路径</param>
        /// <param name="newFile">新路径</param>
        public static void FileMove(string orignFile, string newFile)
        {
            if (string.IsNullOrEmpty(orignFile))
            {
                throw new ArgumentException(orignFile);
            }
            if (string.IsNullOrEmpty(newFile))
            {
                throw new ArgumentException(newFile);
            }
            System.IO.File.Move(orignFile, newFile);
        }

    2.目录常规操作:

        /// <summary>
        /// 在当前目录下创建目录
        /// </summary>
        /// <param name="orignFolder">当前目录</param>
        /// <param name="newFloder">新目录</param>
        public static void FolderCreate(string orignFolder, string newFloder)
        {
            if (string.IsNullOrEmpty(orignFolder))
            {
                throw new ArgumentException(orignFolder);
            }
            if (string.IsNullOrEmpty(newFloder))
            {
                throw new ArgumentException(newFloder);
            }
            Directory.SetCurrentDirectory(orignFolder);
            Directory.CreateDirectory(newFloder);
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="path"></param>
        public static void FolderCreate(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException(path);
            }
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }               
        }

        public static void FileCreate(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException(path);
            }
            var createFile = new FileInfo(path);
            if (createFile.Exists) return;
            var fs = createFile.Create();
            fs.Close();
            fs.Dispose();
        }

        /// <summary>
        /// 递归删除文件夹目录及文件
        /// </summary>
        /// <param name="dir"></param>  
        /// <returns></returns>
        public static void DeleteFolder(string dir)
        {
            if (string.IsNullOrEmpty(dir))
            {
                throw new ArgumentException(dir);
            }
            if (!Directory.Exists(dir)) return;
            foreach (var d in Directory.GetFileSystemEntries(dir))
            {
                if (System.IO.File.Exists(d))
                {
                    //直接删除其中的文件 
                    System.IO.File.Delete(d); 
                }
                else
                {
                    //递归删除子文件夹 
                    DeleteFolder(d);
                }                    
            }
            //删除已空文件夹        
            Directory.Delete(dir, true);          
        }

        /// <summary>
        /// 指定文件夹下面的所有内容copy到目标文件夹下面
        /// </summary>
        /// <param name="srcPath">原始路径</param>
        /// <param name="aimPath">目标文件夹</param>
        public static void CopyDir(string srcPath, string aimPath)
        {
            if (string.IsNullOrEmpty(srcPath))
            {
                throw new ArgumentNullException(srcPath);
            }
            if (string.IsNullOrEmpty(aimPath))
            {
                throw new ArgumentNullException(aimPath);
            }
            try
            {
                if (aimPath[aimPath.Length - 1] != Path.DirectorySeparatorChar)
                {
                    aimPath += Path.DirectorySeparatorChar;
                }
                if (!Directory.Exists(aimPath))
                {
                    Directory.CreateDirectory(aimPath);
                }
                var fileList = Directory.GetFileSystemEntries(srcPath);
                foreach (var file in fileList)
                {
                    if (Directory.Exists(file))
                    {
                        CopyDir(file, aimPath + Path.GetFileName(file));
                    }
                    else
                    {
                        System.IO.File.Copy(file, aimPath + Path.GetFileName(file), true);
                    }
                }
            }
            catch (IOException ioex)
            {
                throw new IOException(ioex.Message);
            }
            catch (Exception ee)
            {
                throw new Exception(ee.ToString());
            }
        }

        /// <summary>
        /// 获取指定文件夹下所有子目录及文件
        /// </summary>
        /// <param name="path">详细路径</param>
        public static string GetFoldAll(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentNullException(path);
            }
            var str =string.Empty;
            var thisOne = new DirectoryInfo(path);
            str = ListTreeShow(thisOne, 0, str);
            return str;

        }

        /// <summary>
        /// 获取指定文件夹下所有子目录及文件函数
        /// </summary>
        /// <param name="theDir">指定目录</param>
        /// <param name="nLevel">默认起始值,调用时,一般为0</param>
        /// <param name="rn">用于迭加的传入值,一般为空</param>
        /// <returns></returns>
        public static string ListTreeShow(DirectoryInfo theDir, int nLevel, string rn)
        {
            if (theDir == null)
            {
                throw new ArgumentNullException("theDir");
            }
            //获得目录
            DirectoryInfo[] subDirectories = theDir.GetDirectories();
            foreach (DirectoryInfo dirinfo in subDirectories)
            {

                if (nLevel == 0)
                {
                    rn += "├";
                }
                else
                {
                    var s =string.Empty;
                    for (int i = 1; i <= nLevel; i++)
                    {
                        s += "│&nbsp;";
                    }
                    rn += s + "├";
                }
                rn += "<b>" + dirinfo.Name + "</b><br />";
                //目录下的文件
                var fileInfo = dirinfo.GetFiles();   
                foreach (FileInfo fInfo in fileInfo)
                {
                    if (nLevel == 0)
                    {
                        rn += "│&nbsp;├";
                    }
                    else
                    {
                        var f = string.Empty;
                        for (int i = 1; i <= nLevel; i++)
                        {
                            f += "│&nbsp;";
                        }
                        rn += f + "│&nbsp;├";
                    }
                    rn += fInfo.Name.ToString() + " <br />";
                }
                rn = ListTreeShow(dirinfo, nLevel + 1, rn);


            }
            return rn;
        }

        /// <summary>
        /// 获取指定文件夹下所有子目录及文件(下拉框形)
        /// </summary>
        /// <param name="path">详细路径</param>
        ///<param name="dropName">下拉列表名称</param>
        ///<param name="tplPath">默认选择模板名称</param>
        public static string GetFoldAll(string path, string dropName, string tplPath)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentNullException(path);
            }
            if (string.IsNullOrEmpty(tplPath))
            {
                throw new ArgumentNullException(tplPath);
            }
            var strDrop = "<select name=\"" + dropName + "\" id=\"" + dropName + "\"><option value=\"\">--请选择详细模板--</option>";
            var str =string.Empty;
            DirectoryInfo thisOne = new DirectoryInfo(path);
            str = ListTreeShow(thisOne, 0, str, tplPath);
            return strDrop + str + "</select>";

        }

        /// <summary>
        /// 获取指定文件夹下所有子目录及文件函数
        /// </summary>
        /// <param name="theDir">指定目录</param>
        /// <param name="nLevel">默认起始值,调用时,一般为0</param>
        /// <param name="rn">用于迭加的传入值,一般为空</param>
        /// <param name="tplPath">默认选择模板名称</param>
        /// <returns></returns>
        public static string ListTreeShow(DirectoryInfo theDir, int nLevel, string rn, string tplPath)
        {
            if (theDir == null)
            {
                throw new ArgumentNullException("theDir");
            }
            //获得目录
            DirectoryInfo[] subDirectories = theDir.GetDirectories();
            foreach (DirectoryInfo dirinfo in subDirectories)
            {
                rn += "<option value=\"" + dirinfo.Name + "\"";
                if (string.Equals(tplPath, dirinfo.Name, StringComparison.CurrentCultureIgnoreCase))
                {
                    rn += " selected ";
                }
                rn += ">";

                if (nLevel == 0)
                {
                    rn += "┣";
                }
                else
                {
                    string s = string.Empty;
                    for (int i = 1; i <= nLevel; i++)
                    {
                        s += "│&nbsp;";
                    }
                    rn += s + "┣";
                }
                rn += "" + dirinfo.Name + "</option>";
                //目录下的文件
                FileInfo[] fileInfo = dirinfo.GetFiles();  
                foreach (FileInfo fInfo in fileInfo)
                {
                    rn += "<option value=\"" + dirinfo.Name + "/" + fInfo.Name + "\"";
                    if (string.Equals(tplPath, fInfo.Name, StringComparison.CurrentCultureIgnoreCase))
                    {
                        rn += " selected ";
                    }
                    rn += ">";

                    if (nLevel == 0)
                    {
                        rn += "│&nbsp;├";
                    }
                    else
                    {
                        string f = string.Empty;
                        for (int i = 1; i <= nLevel; i++)
                        {
                            f += "│&nbsp;";
                        }
                        rn += f + "│&nbsp;├";
                    }
                    rn += fInfo.Name + "</option>";
                }
                rn = ListTreeShow(dirinfo, nLevel + 1, rn, tplPath);
            }
            return rn;
        }

        /// <summary>
        /// 获取文件夹大小
        /// </summary>
        /// <param name="dirPath">文件夹路径</param>
        /// <returns></returns>
        public static long GetDirectoryLength(string dirPath)
        {
            if (string.IsNullOrEmpty(dirPath))
            {
                throw new ArgumentNullException(dirPath);
            }
            if (!Directory.Exists(dirPath))
            {
                return 0;
            }              
            long len = 0;
            DirectoryInfo di = new DirectoryInfo(dirPath);
            foreach (FileInfo fi in di.GetFiles())
            {
                len += fi.Length;
            }
            DirectoryInfo[] dis = di.GetDirectories();
            if (dis.Length > 0)
            {
                for (int i = 0; i < dis.Length; i++)
                {
                    len += GetDirectoryLength(dis[i].FullName);
                }
            }
            return len;
        }

        /// <summary>
        /// 获取指定文件详细属性
        /// </summary>
        /// <param name="filePath">文件详细路径</param>
        /// <returns></returns>
        public static string GetFileAttibe(string filePath)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException(filePath);
            }
            var str = string.Empty;
            FileInfo objFi = new FileInfo(filePath);
            str += "详细路径:" + objFi.FullName + "<br>文件名称:" + objFi.Name + "<br>文件长度:" + objFi.Length + "字节<br>创建时间" + objFi.CreationTime.ToString() + "<br>最后访问时间:" + objFi.LastAccessTime.ToString() + "<br>修改时间:" + objFi.LastWriteTime.ToString() + "<br>所在目录:" + objFi.DirectoryName + "<br>扩展名:" + objFi.Extension;
            return str;
        }

二.DotNet文件目录访问管理:

    1.文件目录权限概述:

       提到权限这个概念,这对于每一个开发者都是再熟悉不过的,因为我们在开发项目时,都会考虑用户权限管理等等,但是文件的权限操作呢?这里我们就简单的介绍一下.NET中对文件访问权限的访问和设置。文件权限中的访问控制列表: 自由访问控制列表(DACL):Microsoft Windows NT和更高版本用于保护资源的机制;系统访问控制列表(SACL):一种控制与资源关联的审核消息的机制。System.Security.AccessControl命名空间通过一些类提供对访问控制列表的访问。DiectorySecurity:该类指定目录的访问控制和审核安全。指定系统目录的访问权限以及访问尝试的审核方式。FileSecurity:该类指定系统文件的访问权限以及如何审核访问尝试。

     下面介绍一下文件权限操作的类和方法:

      (1).FileStream类GetAccessControl():检索文件的安全对象:
[SecuritySafeCritical]
public FileSecurity GetAccessControl()
{
    if (this._handle.IsClosed)
    {
        __Error.FileNotOpen();
    }
    return new FileSecurity(this._handle, this._fileName, AccessControlSections.Group | AccessControlSections.Owner | AccessControlSections.Access);
}
[SecurityCritical, SecurityPermission(SecurityAction.Assert, UnmanagedCode=true)]
internal FileSecurity(SafeFileHandle handle, string fullPath, AccessControlSections includeSections) : base(false, handle, includeSections, false)
{
    if (fullPath != null)
    {
        new FileIOPermission(FileIOPermissionAccess.NoAccess, AccessControlActions.View, fullPath).Demand();
    }
    else
    {
        new FileIOPermission(PermissionState.Unrestricted).Demand();
    }
}
    (2).FileStream类SetAccessControl():保存设置。
[SecuritySafeCritical]
public void SetAccessControl(FileSecurity fileSecurity)
{
    if (fileSecurity == null)
    {
        throw new ArgumentNullException("fileSecurity");
    }
    if (this._handle.IsClosed)
    {
        __Error.FileNotOpen();
    }
    fileSecurity.Persist(this._handle, this._fileName);
}

  2.文件共享操作实例:

    /// <summary>
    /// 共享文档操作
    /// </summary>
    public class FileSharingOperationHelper
    {
        public static bool ConnectState(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentNullException(path);
            }
            return ConnectState(path, "", "");
        }

        /// <summary>
        /// 连接远程共享文件夹
        /// </summary>
        /// <param name="path">远程共享文件夹的路径</param>
        /// <param name="userName">用户名</param>
        /// <param name="passWord">密码</param>
        /// <returns></returns>
        public static bool ConnectState(string path, string userName, string passWord)
        {
            var proc = new Process();
            try
            {
                proc.StartInfo.FileName = "cmd.exe";
                proc.StartInfo.UseShellExecute = false;
                proc.StartInfo.RedirectStandardInput = true;
                proc.StartInfo.RedirectStandardOutput = true;
                proc.StartInfo.RedirectStandardError = true;
                proc.StartInfo.CreateNoWindow = true;
                proc.Start();
                var dosLine = "net use " + path + " " + passWord + " /user:" + userName;
                proc.StandardInput.WriteLine(dosLine);
                proc.StandardInput.WriteLine("exit");
                while (!proc.HasExited)
                {
                    proc.WaitForExit(1000);
                }
                var errormsg = proc.StandardError.ReadToEnd();
                proc.StandardError.Close();
                if (!string.IsNullOrEmpty(errormsg))
                {
                    throw new Exception(errormsg);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                proc.Close();
                proc.Dispose();
            }
            return true;
        }

        /// <summary>
        /// 向远程文件夹保存本地内容,或者从远程文件夹下载文件到本地
        /// </summary>
        /// <param name="src">要保存的文件的路径,如果保存文件到共享文件夹,这个路径就是本地文件路径如:@"D:\1.avi"</param>
        /// <param name="dst">保存文件的路径,不含名称及扩展名</param>
        /// <param name="fileName">保存文件的名称以及扩展名</param>
        public static void Transport(string src, string dst, string fileName)
        {
            if (string.IsNullOrEmpty(src))
            {
                throw new ArgumentNullException(src);
            }
            if (string.IsNullOrEmpty(dst))
            {
                throw new ArgumentNullException(dst);
            }
            if (string.IsNullOrEmpty(fileName))
            {
                throw new ArgumentNullException(fileName);
            }
            FileStream inFileStream = null;
            FileStream outFileStream = null;
            try
            {
                inFileStream = new FileStream(src, FileMode.Open);
                if (!Directory.Exists(dst))
                {
                    Directory.CreateDirectory(dst);
                }
                dst = dst + fileName;
                outFileStream = new FileStream(dst, FileMode.OpenOrCreate);
                var buf = new byte[inFileStream.Length];
                int byteCount;
                while ((byteCount = inFileStream.Read(buf, 0, buf.Length)) > 0)
                {
                    outFileStream.Write(buf, 0, byteCount);
                }
            }
            catch (IOException ioex)
            {
                throw new IOException(ioex.Message);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                if (inFileStream != null)
                {
                    inFileStream.Flush();
                    inFileStream.Close();
                }
                if (outFileStream != null)
                {
                    outFileStream.Flush();
                    outFileStream.Close();
                }
            }
        }
    }

    文件权限的规则:容器的访问规则可能被配置为不仅应用于对象本身,而且还应用于它的子对象、子容器或这两者。每个访问规则不是显示的就是继承的。DACL可以有对象的所有者任意修改,还可以由所有者已经给予其梗概DACL权限的任何更改。对象的安全描述包含另一个规则列表,称为系统访问权限列表(SACL),该列表将控制系统对对象执行哪个类型的审核。审核是一种具有安全敏感性的操作。在windows中,审核只能由本地安全机构(LSA)生成,LSA是唯一允许向安全事件日志中写入的组件。

三.DotNet彻底删除文件操作:

    1.文件彻底删除概述:

       看到文件删除,可能有人会问,前面不是已经介绍过文件的删除操作吗?为什么这里还需要详细的介绍。不错,上面的确介绍了文件和目录的删除方法,但是这里是介绍如何彻底的删除文件。我们常规的删除文件和文件格式化,一般是可以被恢复的。我们在操作删除的时候,只是将文件的索引给删除了,并没有删除实际的内容。文件的索引记录了文件在磁盘中的位置信息,当执行删除操作时,只是从文件分配聊表中删除了目录。

       那么可能会有人问,怎么讲文件彻底的删除呢?文件的粉碎,其实就是在删除文件分配列表的同时,把文件在磁盘上占用的所有扇区数据置为0。

       在.NET中提供了两种文件彻底的方法:

          (1).调用系统API来完成这样的“粉碎”操作。

          (2).在删除文件之前先删除文件的所有内容,然后在执行删除操作,被称为“假粉碎”。(此方法可以被人恢复文件,但是恢复的数据只是文件中的0)

      为了文件安全,可以采用多轮粉碎的方式:第一轮,通过文件操作Windows API,找到原始文件的铭文在存储器上所载区域,逐字符逐位进行完全填充,全部填充为0。第二轮,通过磁盘操作WindowsAPI找到原始文件或目录在FAT表中的位置,将原始文件或目录在FAT表中项清零。第三轮,通过磁盘操作WindowsAPI,找到原始文件或目录在备份FAT表的位置,将原始文件或目录在备份FAT表中的表项清零。

    2.文件彻底删除实例:

    /// <summary>
    /// 粉碎文件操作
    /// </summary>
    public class KillFileHelper
    {
        /// <summary>
        /// 强力粉碎文件,文件如果被打开,很难粉碎
        /// </summary>
        /// <param name="filename">文件全路径</param>
        /// <param name="deleteCount">删除次数</param>
        /// <param name="randomData">随机数据填充文件,默认true</param>
        /// <param name="blanks">空白填充文件,默认false</param>
        /// <returns>true:粉碎成功,false:粉碎失败</returns>
        public static bool KillFile(string filename, int deleteCount, bool randomData = true, bool blanks = false)
        {
            if (string.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException(filename);
            }
            const int bufferLength = 1024000;
            var ret = true;
            try
            {
                using (var stream = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
                {
                    var f = new FileInfo(filename);
                    var count = f.Length;
                    long offset = 0;
                    var rowDataBuffer = new byte[bufferLength];
                    while (count >= 0)
                    {
                        var iNumOfDataRead = stream.Read(rowDataBuffer, 0, bufferLength);
                        if (iNumOfDataRead == 0)
                        {
                            break;
                        }
                        if (randomData)
                        {
                            var randombyte = new Random();
                            randombyte.NextBytes(rowDataBuffer);
                        }
                        else if (blanks)
                        {
                            for (var i = 0; i < iNumOfDataRead; i++)
                                rowDataBuffer[i] = 0;
                        }
                        else
                        {
                            for (var i = 0; i < iNumOfDataRead; i++)
                                rowDataBuffer[i] = Convert.ToByte(Convert.ToChar(deleteCount));
                        }
                        // 写新内容到文件。
                        for (var i = 0; i < deleteCount; i++)
                        {
                            stream.Seek(offset, SeekOrigin.Begin);
                            stream.Write(rowDataBuffer, 0, iNumOfDataRead);
                        }
                        offset += iNumOfDataRead;
                        count -= iNumOfDataRead;
                    }
                }
                //每一个文件名字符代替随机数从0到9。
                var newName = "";
                do
                {
                    var random = new Random();
                    var cleanName = Path.GetFileName(filename);
                    var dirName = Path.GetDirectoryName(filename);
                    var iMoreRandomLetters = random.Next(9);
                    // 为了更安全,不要只使用原文件名的大小,添加一些随机字母。
                    for (var i = 0; i < cleanName.Length + iMoreRandomLetters; i++)
                    {
                        newName += random.Next(9).ToString();
                    }
                    newName = dirName + "\\" + newName;
                } while (File.Exists(newName));
                // 重命名文件的新的随机的名字。
                File.Move(filename, newName);
                File.Delete(newName);
            }
            catch
            {
                //可能其他原因删除失败了,使用我们自己的方法强制删除
                var matchPattern = @"(?<=\s+pid:\s+)\b(\d+)\b(?=\s+)";
                try
                {
                    //要检查被那个进程占用的文件
                    var fileName = filename;
                    var tool = new Process { StartInfo = { FileName = "handle.exe", Arguments = fileName + " /accepteula", UseShellExecute = false, RedirectStandardOutput = true } };
                    tool.Start();
                    tool.WaitForExit();
                    var outputTool = tool.StandardOutput.ReadToEnd();
                    foreach (Match match in Regex.Matches(outputTool, matchPattern))
                    {
                        //结束掉所有正在使用这个文件的程序
                        Process.GetProcessById(int.Parse(match.Value)).Kill();
                    }
                    File.Delete(fileName);
                }
                catch
                {
                    ret = false;
                }
            }
            return ret;
        }
    }

四.DotNet文件加密解密操作:

   上面介绍了文件的基本操作,文件权限操作,文件的删除操作,最后介绍一下文件的加密和解密操作。File和FileInfo类对文件加密进行了进一步的封装,提供了Encrypt和Decrypt方法用来对文件加密和解密。这两种方法要求文件系统必须为NFTS系统,对操作系统版本也要求必须是NT以上版本,使用该方法加密的文件,必须由同一用户才能进行解密。

   具体看一下该方法的实现代码:

   1.Encrypt():文件加密操作。

[SecuritySafeCritical]
public static void Encrypt(string path)
{
    if (path == null)
    {
        throw new ArgumentNullException("path");
    }
    string fullPathInternal = Path.GetFullPathInternal(path);
    new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new string[] { fullPathInternal }, false, false).Demand();
    if (!Win32Native.EncryptFile(fullPathInternal))
    {
        int errorCode = Marshal.GetLastWin32Error();
        if (errorCode == 5)
        {
            DriveInfo info = new DriveInfo(Path.GetPathRoot(fullPathInternal));
            if (!string.Equals("NTFS", info.DriveFormat))
            {
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_EncryptionNeedsNTFS"));
            }
        }
        __Error.WinIOError(errorCode, fullPathInternal);
    }
}

   2.Decrypt():文件解密操作。

[SecuritySafeCritical]
public static void Decrypt(string path)
{
    if (path == null)
    {
        throw new ArgumentNullException("path");
    }
    string fullPathInternal = Path.GetFullPathInternal(path);
    new FileIOPermission(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, new string[] { fullPathInternal }, false, false).Demand();
    if (!Win32Native.DecryptFile(fullPathInternal, 0))
    {
        int errorCode = Marshal.GetLastWin32Error();
        if (errorCode == 5)
        {
            DriveInfo info = new DriveInfo(Path.GetPathRoot(fullPathInternal));
            if (!string.Equals("NTFS", info.DriveFormat))
            {
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_EncryptionNeedsNTFS"));
            }
        }
        __Error.WinIOError(errorCode, fullPathInternal);
    }
}

五.总结:

    以上简单的介绍了文件的操作和文件的权限管理方法,如果需要更加深入的了解这些操作方法,可以查看msdn,或者查看.NET的“垫片”,查看相应的接口。在当代社会中,数据安全和文件安全都是很重要的,我们应该更加深入的去学习安全知识,提高系统的稳定性。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏鬼谷君

Salt-API安装配置及使用

912
来自专栏.NET开发者社区

一步一步创建ASP.NET MVC5程序[Repository+Autofac+Automapper+SqlSugar](四)

上一篇《一步一步创建ASP.NET MVC5程序[Repository+Autofac+Automapper+SqlSugar](三)》,我们完成了:

1899
来自专栏葡萄城控件技术团队

ASP.NET MVC 5 - 查询Details和Delete方法

在这部分教程中,接下来我们将讨论自动生成的Details和Delete方法。 查询Details和Delete方法 打开Movie控制器并查看Details方法...

1856
来自专栏一个爱瞎折腾的程序猿

winform制作小工具的技巧

在使用winfrom制作一些工具的时候,一些基本设置都是去属性里面找来找去,一段时间就忘了,记录记录以备不时之需。

863
来自专栏跟着阿笨一起玩NET

焦点事件中的Validating处理方法

本文转载:http://tech.it168.com/oldarticle/2006-04-03/200604031055437.shtml

391
来自专栏葡萄城控件技术团队

ASP.NET 5系列教程(七)完结篇-解读代码

在本文中,我们将一起查看TodoController 类代码。 [Route] 属性定义了Controller的URL 模板: [Route("api/[con...

1855
来自专栏Bug生活2048

.net core下对于附件上传下载的实现

.net core通过IFormFile接收文件对象,再通过流的方式保存至指定的地方。

643
来自专栏GuZhenYin

使用localResizeIMG3+WebAPI实现手机端图片上传

前言 惯例~惯例~昨天发表的使用OWIN作为WebAPI的宿主..嗯..有很多人问..是不是缺少了什么 - - 好吧,如果你要把OWIN寄宿在其他的地方...代...

1888
来自专栏菩提树下的杨过

Silverlight Telerik控件学习:弹出窗口RadWindow

几乎所有的业务系统都有弹出窗口,典型场景有二种 : 1、简单的弹出一个对话框显示信息,比如下面这样: ? 这个很简单,代码示例如下: DialogParamet...

1875
来自专栏逸鹏说道

上传伪技术~很多人都以为判断了后缀,判断了ContentType,判断了头文件就真的安全了。是吗?

今天群里有人聊图片上传,简单说下自己的经验(大牛勿喷) 0.如果你的方法里面是有指定路径的,记得一定要过滤../,比如你把 aa文件夹设置了权限,一些类似于ex...

3428

扫码关注云+社区