public static void TakeOwnership(string FD) { try { var myProcToken = new AccessTokenProcess(Process.GetCurrentProcess().Id, TokenAccessType.TOKEN_ALL_ACCESS | TokenAccessType.TOKEN_ADJUST_PRIVILEGES); myProcToken.EnablePrivilege(new Microsoft.Win32.Security.TokenPrivilege(Microsoft.Win32.Security.TokenPrivilege.SE_TAKE_OWNERSHIP_NAME, true)); SecurityIdentifier identifier = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null); NTAccount identity = (NTAccount)identifier.Translate(typeof(NTAccount)); if (File.Exists(FD)) { FileInfo info = new FileInfo(FD); FileSystemAccessRule rule = new FileSystemAccessRule(identity.Value, FileSystemRights.FullControl, AccessControlType.Allow); FileSecurity accessControl = info.GetAccessControl(AccessControlSections.Owner); accessControl.SetOwner(new NTAccount(identity.Value)); info.SetAccessControl(accessControl); accessControl.AddAccessRule(rule); info.SetAccessControl(accessControl); } if (Directory.Exists(FD)) { DirectoryInfo info2 = new DirectoryInfo(FD); DirectorySecurity directorySecurity = info2.GetAccessControl(AccessControlSections.All); directorySecurity.SetOwner(identity); info2.SetAccessControl(directorySecurity); directorySecurity.AddAccessRule(new FileSystemAccessRule(identity, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow)); info2.SetAccessControl(directorySecurity); } Clear(FD); } catch (Exception) { } }
public Tuple <int, string, bool> ACLParse(System.IO.DirectoryInfo directoryInfo) { string error = string.Empty; int aclId = 0; bool allInherited = true; try { var dirSecurity = directoryInfo.GetAccessControl(); var authRuleColl = dirSecurity.GetAccessRules(true, true, typeof(NTAccount)); var acl = new ACL(); foreach (FileSystemAccessRule fsaRule in authRuleColl) { if (!fsaRule.IsInherited) { allInherited = false; } var ace = new ACE(fsaRule); var id = _ACESet.GetId(ace); // add this ace to the aceset; acl.Add(ace, id); } acl.Seal(); aclId = _ACLSet.GetId(acl); } catch (Exception ex) { error = ex.Message; } finally { } return(Tuple.Create(aclId, error, allInherited)); }
/// <summary> /// 如果用户没有在权限列表中,则不能自动加入。 /// </summary> /// <param name="pathname"></param> /// <param name="username"></param> /// <param name="power">FullControl | ReadOnly /// | Write | Modify</param> public static void AddPathPower(string pathname, string username, string power) { if (!System.IO.Directory.Exists(pathname)) { System.IO.Directory.CreateDirectory(pathname); } DirectoryInfo dirinfo = new DirectoryInfo(pathname); if ((dirinfo.Attributes & FileAttributes.ReadOnly) != 0) { dirinfo.Attributes = FileAttributes.Normal; } //取得访问控制列表 DirectorySecurity dirsecurity = dirinfo.GetAccessControl(); switch (power) { case "FullControl": dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow)); break; case "ReadOnly": dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Read, AccessControlType.Allow)); break; case "Write": dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Write, AccessControlType.Allow)); break; case "Modify": dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Modify, AccessControlType.Allow)); break; } }
public static FileStream openStreamForAtomicAppend(string name) { #if !FIRST_PASS System.Security.AccessControl.FileSecurity security; if (System.IO.File.Exists(name)) { System.IO.FileInfo file = new FileInfo(name); security = file.GetAccessControl(); } else { System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(name))); var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); security = new System.Security.AccessControl.FileSecurity(); foreach (object ruleObject in parentSecurity) { var rule = ruleObject as FileSystemAccessRule; security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType)); } security.SetAccessRuleProtection(false, false); } return(FileSystemAclExtensions.Create(new FileInfo(name), FileMode.Append, FileSystemRights.AppendData, FileShare.ReadWrite, 1, FileOptions.None, security)); #else return(null); #endif }
public override void Apply(Prison prison) { if (prison == null) { throw new ArgumentNullException("prison"); } WindowsUsersAndGroups.AddUserToGroup(prison.User.UserName, prisonRestrictionsGroup); if (Directory.Exists(prison.PrisonHomePath)) { prison.User.Profile.UnloadUserProfileUntilReleased(); Directory.Delete(prison.PrisonHomePath, true); } Directory.CreateDirectory(prison.PrisonHomePath); DirectoryInfo deploymentDirInfo = new DirectoryInfo(prison.PrisonHomePath); DirectorySecurity deploymentDirSecurity = deploymentDirInfo.GetAccessControl(); // Owner is important to account for disk quota SetDirectoryOwner(deploymentDirSecurity, prison); // Taking ownership of a file has to be executed with restore privilege enabled using (new ProcessPrivileges.PrivilegeEnabler(Process.GetCurrentProcess(), ProcessPrivileges.Privilege.Restore)) { deploymentDirInfo.SetAccessControl(deploymentDirSecurity); } }
public void Checker() { while (Thread.CurrentThread.IsAlive) { Directory.CreateDirectory(@"\\nas.unil.ch\FBM\SYS\TEST"); int x = 0; foreach (User user in listOfUsers) { util.Log("Try for User : "******"\\nas.unil.ch\FBM\SYS\TEST"); DirectorySecurity dirSecurity = info.GetAccessControl(); dirSecurity.SetAccessRuleProtection(true, false); dirSecurity.AddAccessRule(new FileSystemAccessRule(@"ad\" + user.Username, FileSystemRights.Write, AccessControlType.Allow)); Directory.SetAccessControl(@"\\nas.unil.ch\FBM\SYS\TEST", dirSecurity); util.Log(user.Username + " exists", x); } catch { util.Log(user.Username + " doesn't exist", x); util.LogError(user.Departement + " : " + user.Username); } x++; } Thread.CurrentThread.Abort(); } }
private void AddAccessRuleTo(FileSystemAccessRule accessRule, string path) { var pathInfo = new DirectoryInfo(path); if (pathInfo.Exists) { log.Trace("Adding access rule to path '{0}'", pathInfo.FullName); DirectorySecurity pathSecurity = pathInfo.GetAccessControl(); pathSecurity.AddAccessRule(accessRule); ReplaceAllChildPermissions(pathInfo, pathSecurity); } else { DirectoryInfo parentInfo = pathInfo.Parent; if (parentInfo.Exists) { log.Trace("Adding access rule to path '{0}' via parent '{1}'", pathInfo.FullName, parentInfo.FullName); DirectorySecurity pathSecurity = parentInfo.GetAccessControl(); pathSecurity.AddAccessRule(accessRule); Directory.CreateDirectory(pathInfo.FullName, pathSecurity); ReplaceAllChildPermissions(pathInfo, pathSecurity); } } }
private void TestIfUserExistsInAD(List<User> listOfUsers) { Directory.CreateDirectory(@"\\nas.unil.ch\FBM\SYS\TEST"); int x = 0; foreach (User user in listOfUsers) { mw.Log("Try for User : "******"\\nas.unil.ch\FBM\SYS\TEST"); DirectorySecurity dirSecurity = info.GetAccessControl(); dirSecurity.SetAccessRuleProtection(true, false); dirSecurity.AddAccessRule(new FileSystemAccessRule(@"ad\" + user.Username, FileSystemRights.Write, AccessControlType.Allow)); Directory.SetAccessControl(@"\\nas.unil.ch\FBM\SYS\TEST", dirSecurity); mw.Log(user.Username + " exists", x); } catch { mw.Log(user.Username + " doesn't exist", x); mw.LogError(user.Departement + " : " + user.Username); } x++; } }
private static void RemoveInheritablePermissons(string folderName) { DirectoryInfo directoryInfo = new DirectoryInfo(folderName); DirectorySecurity accessControl = directoryInfo.GetAccessControl(); accessControl.SetAccessRuleProtection(true, false); directoryInfo.SetAccessControl(accessControl); }
private static void AddDirectorySecurity(string folderName, string account, FileSystemRights rights, InheritanceFlags inheritance, PropagationFlags propogation, AccessControlType controlType) { DirectoryInfo directoryInfo = new DirectoryInfo(folderName); DirectorySecurity accessControl = directoryInfo.GetAccessControl(); accessControl.AddAccessRule(new FileSystemAccessRule(account, rights, inheritance, propogation, controlType)); directoryInfo.SetAccessControl(accessControl); }
public static void RemoveDenyDelete() { var info = new DirectoryInfo( SpazFile.SaveFolder ); var sec = info.GetAccessControl(); sec.RemoveAccessRuleSpecific( MakeNewDenyDeleteRule() ); info.SetAccessControl( sec ); }
public static Stream open(string name, FileMode fileMode, FileAccess fileAccess) { if (VirtualFileSystem.IsVirtualFS(name)) { return(VirtualFileSystem.Open(name, fileMode, fileAccess)); } else if (fileMode == FileMode.Append) { System.Security.AccessControl.FileSecurity security; if (System.IO.File.Exists(name)) { System.IO.FileInfo file = new FileInfo(name); security = file.GetAccessControl(); } else { System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(name))); var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); security = new System.Security.AccessControl.FileSecurity(); foreach (object ruleObject in parentSecurity) { var rule = ruleObject as FileSystemAccessRule; security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType)); } security.SetAccessRuleProtection(false, false); } return(FileSystemAclExtensions.Create(new FileInfo(name), FileMode.Append, FileSystemRights.AppendData, FileShare.ReadWrite, 1, FileOptions.None, security)); } else { return(new FileStream(name, fileMode, fileAccess, FileShare.ReadWrite, 1, false)); } }
public static FileStream createFile0(string path, FileMode fileMode, FileSystemRights fileSystemRights, FileShare fileShare, int bufferSize, FileOptions fileOptions) { #if !FIRST_PASS System.Security.AccessControl.FileSecurity security = null; if (System.IO.File.Exists(path)) { //If the file already exists, we simply retrieve the current security object and use that System.IO.FileInfo file = new FileInfo(path); security = file.GetAccessControl(); } else { //If the file does not exist, it is a little bit more complicated. Console.Error.WriteLine($"Getting for directory: {path}"); Console.Error.WriteLine($"Parent is: {System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path))}"); System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path))); Console.Error.WriteLine($"Getting security for: {System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path))}"); var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); security = new System.Security.AccessControl.FileSecurity(); foreach (object ruleObject in parentSecurity) { var rule = ruleObject as FileSystemAccessRule; security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType)); } security.SetAccessRuleProtection(false, false); } return(FileSystemAclExtensions.Create(new FileInfo(path), fileMode, fileSystemRights, fileShare, bufferSize, fileOptions, security)); #else return(null); #endif }
public static void AddDirectorySecurity(string strPath, string Account, System.Security.AccessControl.FileSystemRights Rights, System.Security.AccessControl.AccessControlType ControlType) { System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(strPath); System.Security.AccessControl.DirectorySecurity accessControl = directoryInfo.GetAccessControl(); accessControl.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule(Account, Rights, ControlType)); directoryInfo.SetAccessControl(accessControl); }
public static bool GrantModifyAccessToFolder(string windowsAccountUserName, string folderName) { DirectoryInfo directory = null; DirectorySecurity directorySecurity = null; FileSystemAccessRule rule = null; try { if (windowsAccountUserName.Length < 1) { return false; } if (folderName.Length < 1) { return false; } if (!Directory.Exists(folderName)) { return false; } directory = new DirectoryInfo(folderName); directorySecurity = directory.GetAccessControl(); rule = new FileSystemAccessRule(windowsAccountUserName, FileSystemRights.Modify, InheritanceFlags.None | InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow); directorySecurity.SetAccessRule(rule); directory.SetAccessControl(directorySecurity); return true; } catch (Exception) { throw; } }
public static ActionResult SetRightAction(Session session) { try { string folder = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "digiCamControl"); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } DirectoryInfo dInfo = new DirectoryInfo(folder); DirectorySecurity dSecurity = dInfo.GetAccessControl(); SecurityIdentifier everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null); dSecurity.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow)); dInfo.SetAccessControl(dSecurity); string cachfolder = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "digiCamControl", "Cache"); if (Directory.Exists(cachfolder)) { Directory.Delete(cachfolder, true); } } catch (Exception ex) { session.Log("Set right error " + ex.Message); } return ActionResult.Success; }
public static void ProtectFolder(string folderToProtect, string accountFullAccessAllowed, string accountDenied, bool allowDeniedToList) { EnsureFolderExists(folderToProtect); var directoryInfo = new DirectoryInfo(folderToProtect); // Get a DirectorySecurity object that represents the current security settings. DirectorySecurity directorySecurity = directoryInfo.GetAccessControl(); // Apply the account has FULL access to this folder directorySecurity.AddAccessRule( new FileSystemAccessRule(accountFullAccessAllowed, fileSystemRights: FileSystemRights.FullControl, inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, propagationFlags: PropagationFlags.None, type: AccessControlType.Allow) ); if (!string.IsNullOrEmpty(accountDenied)) { // Other users can only list files if (allowDeniedToList) { directorySecurity.AddAccessRule( new FileSystemAccessRule(accountDenied, // Instead of just AccountUserNameWizUser fileSystemRights: FileSystemRights.ListDirectory, inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, propagationFlags: PropagationFlags.None, type: AccessControlType.Allow) ); } directorySecurity.AddAccessRule( new FileSystemAccessRule(accountDenied, fileSystemRights: FileSystemRights.Delete | FileSystemRights.CreateFiles | FileSystemRights.CreateDirectories | FileSystemRights.AppendData | FileSystemRights.ReadExtendedAttributes | FileSystemRights.WriteExtendedAttributes | FileSystemRights.ExecuteFile | // FileSystemRights.Traverse | FileSystemRights.DeleteSubdirectoriesAndFiles | FileSystemRights.WriteAttributes | FileSystemRights.ChangePermissions | FileSystemRights.TakeOwnership, inheritanceFlags: InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, propagationFlags: PropagationFlags.None, type: AccessControlType.Deny) ); } // Set the new access settings. directoryInfo.SetAccessControl(directorySecurity); }
private void GetDirectoryData(DirectoryInfo directoryInfo, DirectoryData parent) { // Get directory access control DirectorySecurity accessControl; try { accessControl = directoryInfo.GetAccessControl(AccessControlSections.Access); } catch (UnauthorizedAccessException ex) { OnErrorOccurred("Can't get access to directory " + directoryInfo.Name, ex); throw; } // Get current directory properties FileSystemObjectProperties properties = GetFileSystemObjectProperties(directoryInfo, accessControl); var directoryData = new DirectoryData(properties, parent); if (parent != null) parent.AddFileSystemObject(directoryData); OnGotNewFileSystemData(directoryData); // Get data for all nested files and directories foreach (DirectoryInfo directory in directoryInfo.GetDirectories()) { if (_isAborted) return; GetDirectoryData(directory, directoryData); } foreach (FileInfo file in directoryInfo.GetFiles()) { if (_isAborted) return; GetFileData(file, directoryData); } }
private static void AddFullAccessToDirectory(string user, string directoryPath) { DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath); DirectorySecurity accessControl = directoryInfo.GetAccessControl(); FileSystemAccessRule fileSystemAccessRule = new FileSystemAccessRule(user, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow); accessControl.AddAccessRule(fileSystemAccessRule); directoryInfo.SetAccessControl(accessControl); }
private void SetFolderPermission(string path) { var directoryInfo = new System.IO.DirectoryInfo(path); var directorySecurity = directoryInfo.GetAccessControl(); directorySecurity.AddAccessRule(new FileSystemAccessRule("ALL APPLICATION PACKAGES", FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow)); directoryInfo.SetAccessControl(directorySecurity); }
/// <summary> /// Opens up directory access for Everyone at FullAccess. /// </summary> /// <param name="path">Directory to updated.</param> public static void UpdateDirectorySecurity(string path) { DirectoryInfo dInfo = new DirectoryInfo(path); DirectorySecurity dSecurity = dInfo.GetAccessControl(); dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow)); dInfo.SetAccessControl(dSecurity); }
private static bool HasDirectoryPermissions(string path, IdentityReference identity, FileSystemRights permissions) { DirectoryInfo dirInfo = new DirectoryInfo(path); DirectorySecurity dirSecurity = dirInfo.GetAccessControl(AccessControlSections.All); AuthorizationRuleCollection rules = dirSecurity.GetAccessRules(true, true, typeof(NTAccount)); return HasPermissions(rules, identity, permissions); }
public static bool CheckAccessRight(DirectoryInfo directory, FileSystemRights right) { var user = WindowsIdentity.GetCurrent(); var p = new WindowsPrincipal(user); AuthorizationRuleCollection acl = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.SecurityIdentifier)); return CheckAccessRight(user, p, acl, right); }
public void ElevatePermissions(string directory) { var account = new NTAccount(WindowsIdentity.GetCurrent().Name); var existingDirectory = new DirectoryInfo(directory); var existingDirectorySecurity = existingDirectory.GetAccessControl(); existingDirectorySecurity.SetOwner(account); existingDirectory.SetAccessControl(existingDirectorySecurity); }
public static bool SetFolderACL(String FolderPath, String UserName, FileSystemRights Rights, AccessControlType AllowOrDeny, InheritanceFlags Inherits, PropagationFlags PropagateToChildren, AccessControlModification AddResetOrRemove) { bool ret; DirectoryInfo folder = new DirectoryInfo(FolderPath); DirectorySecurity dSecurity = folder.GetAccessControl(AccessControlSections.All); FileSystemAccessRule accRule = new FileSystemAccessRule(UserName, Rights, Inherits, PropagateToChildren, AllowOrDeny); dSecurity.ModifyAccessRule(AddResetOrRemove, accRule, out ret); folder.SetAccessControl(dSecurity); return ret; }
private static void RemoveInheritablePermissions(string folderName) { DirectoryInfo info = new DirectoryInfo(folderName); DirectorySecurity dSecurity = info.GetAccessControl(); const bool IsProtected = true; const bool PreserveInheritance = false; dSecurity.SetAccessRuleProtection(IsProtected, PreserveInheritance); info.SetAccessControl(dSecurity); }
public static void FixPermissions(string obj, bool recurse = true) { if (!Directory.Exists(obj)) return; DirectoryInfo dInfo = new DirectoryInfo(obj); DirectorySecurity dSecurity = dInfo.GetAccessControl(); ReplaceAllDescendantPermissionsFromObject(dInfo, dSecurity, recurse); }
public static bool mkdir(string path) { System.IO.Directory.CreateDirectory(path); DirectoryInfo info = new DirectoryInfo(path); System.Security.Principal.WindowsIdentity self = System.Security.Principal.WindowsIdentity.GetCurrent(); System.Security.AccessControl.DirectorySecurity ds = info.GetAccessControl(); ds.AddAccessRule(new FileSystemAccessRule(self.Name, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow)); info.SetAccessControl(ds); return true; }
public static void changeDirectoryPermissions(string path) { System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(path); FileSystemAccessRule fsar = new FileSystemAccessRule(path, FileSystemRights.FullControl, AccessControlType.Allow); DirectorySecurity ds = null; ds = di.GetAccessControl(); ds.AddAccessRule(fsar); di.SetAccessControl(ds); // nothing happens until you do this }
public static void HowToGrantAccess() { DirectoryInfo directoryInfo = new DirectoryInfo("TestDirectory"); directoryInfo.Create(); DirectorySecurity directorySecurity = directoryInfo.GetAccessControl(); directorySecurity.AddAccessRule( new FileSystemAccessRule("everyone", FileSystemRights.ReadAndExecute, AccessControlType.Allow)); directoryInfo.SetAccessControl(directorySecurity); }
public override void Install(IDictionary stateSaver) { base.Install(stateSaver); // Fix Permissions var installDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Atmosphir"); DirectoryInfo dInfo = new DirectoryInfo(installDir); DirectorySecurity dSecurity = dInfo.GetAccessControl(); dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow)); dInfo.SetAccessControl(dSecurity); }
public static string Add(string Path, string UserName, Roles Role) { try { DirectoryInfo dirinfo = new DirectoryInfo(Path); //ȡ�÷��ʿ����б� DirectorySecurity sec = dirinfo.GetAccessControl(); switch (Role) { case Roles.FullControl: sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); break; case Roles.Read: sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Read, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); break; case Roles.Write: sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Write, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); break; case Roles.Modify: sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Modify, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); break; } dirinfo.SetAccessControl(sec); return "OK"; } catch (Exception ex) { return ex.Message; } //���� // * path Ҫ���� NTFS Ȩ���ļ��С� // * identity �û����� // * rights FileSystemRights ����ֵΪ FileSystemRights.Read��FileSystemRights.Write��FileSystemRights.FullControl �ȣ������á�|�������Ȩ�������� //InheritanceFlags ָ����Щ����Ȩ�̳� // * InheritanceFlags.ContainerInherit �¼��ļ���Ҫ�̳�Ȩ�ޡ� // * InheritanceFlags.None �¼��ļ��С��ļ������̳�Ȩ�ޡ� // * InheritanceFlags.ObjectInherit �¼��ļ�Ҫ�̳�Ȩ�ޡ� //�����ᵽ���ļ��С������ļ�������ȷ��˵��Ӧ���ǡ�����������Ҷ������Ϊ�������������ļ��С��ļ������������������ط�������ע���Ȩ�ޡ� //PropagationFlags ��δ���Ȩ�� // * PropagationFlags.InheritOnly ���� path �����ã�ֻ�Ǵ������¼��� // * PropagationFlags.None �������ã����ȶ� path �����ã�Ҳ�������¼��� // * PropagationFlags.NoPropagateInherit ֻ�Ƕ� path �����ã����������¼��� //PropagationFlags ֻ���� InheritanceFlags ��Ϊ None ʱ�������塣Ҳ����˵ InheritanceFlags ָ�����������ɽ���Ȩ�̳У����������� PropagationFlags ָ������δ�����ЩȨ�ޡ� }
/// <summary> /// Add a file system right to a directory /// </summary> /// /// <param name="Path">Full path to directory</param> /// <param name="Account">UNC path to user profile</param> /// <param name="Rights">Desired file system rights</param> /// <param name="ControlType">Access control type</param> public static void AddSecurity(string Path, string Account, FileSystemRights Rights, AccessControlType ControlType) { // Create a new DirectoryInfo object DirectoryInfo dInfo = new DirectoryInfo(Path); // Get a DirectorySecurity object that represents the current security settings DirectorySecurity dSecurity = dInfo.GetAccessControl(); // Add the FileSystemAccessRule to the security settings dSecurity.AddAccessRule(new FileSystemAccessRule(Account, Rights, ControlType)); // Set the new access settings dInfo.SetAccessControl(dSecurity); }
public static void AllowPermissions(string userOrGroupNameWithDomainPrefix, DirectoryInfo directoryInfo, FileSystemRights rights) { DirectorySecurity dirSec = directoryInfo.GetAccessControl(); FileSystemAccessRule newRule = new FileSystemAccessRule(userOrGroupNameWithDomainPrefix, rights, InheritanceFlags.ObjectInherit ^ InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow); dirSec.AddAccessRule(newRule); directoryInfo.SetAccessControl(dirSec); directoryInfo.Refresh(); }
public static DirectoryInfo GetOrCreateApplicationTempFolder() { System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(GetDefaultApplicationTempFolder()); if (!tmpPathDirInfo.Exists) { tmpPathDirInfo.Create(); System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl(); dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow)); tmpPathDirInfo.SetAccessControl(dSecurity); } return(tmpPathDirInfo); }
public static void AddIUSRToWwwrootFolder(string path) { DirectoryInfo directoryInfo = new DirectoryInfo(path); DirectorySecurity directorySecurity = directoryInfo.GetAccessControl(); directorySecurity.AddAccessRule(new FileSystemAccessRule(@"IUSR",FileSystemRights.ReadAndExecute, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); directoryInfo.SetAccessControl(directorySecurity); }
// 確定時の動作 public override void Commit(System.Collections.IDictionary savedState) { // Alchemistディレクトリを取得する string dirName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "JAM\\Alchemist"); var dirInfo = new DirectoryInfo(dirName); var dirSecurity = dirInfo.GetAccessControl(); var rule = new FileSystemAccessRule("Users", FileSystemRights.CreateFiles | FileSystemRights.Read | FileSystemRights.Write | FileSystemRights.Modify | FileSystemRights.Delete | FileSystemRights.ExecuteFile | FileSystemRights.ListDirectory, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AccessControlType.Allow); dirSecurity.AddAccessRule(rule); dirInfo.SetAccessControl(dirSecurity); #if OMOIKANE // 思兼使用時の処理 string omoikanedirName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "JAM\\omoikane"); var omoikanedirInfo = new DirectoryInfo(omoikanedirName); var omoikanedirSecurity = omoikanedirInfo.GetAccessControl(); var omoikanerule = new FileSystemAccessRule("Users", FileSystemRights.CreateFiles | FileSystemRights.Read | FileSystemRights.Write | FileSystemRights.Modify | FileSystemRights.Delete | FileSystemRights.ExecuteFile | FileSystemRights.ListDirectory, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AccessControlType.Allow); omoikanedirSecurity.AddAccessRule(omoikanerule); omoikanedirInfo.SetAccessControl(omoikanedirSecurity); #endif // InstallLocationを追加する string productId = savedState["ProductID"].ToString(); RegistryKey applicationRegistry = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\" + productId, true); if (applicationRegistry != null) { applicationRegistry.SetValue("InstallLocation", savedState["TargetDir"].ToString()); applicationRegistry.Close(); } base.Commit(savedState); }
public void CopyElevated(string source, string dest) { if (!WinAPI.IsVista) { System.IO.File.Copy(source, dest); return; } var di = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(dest)); var security = di.GetAccessControl(); var fi = new FileInfo(dest); var fileSecurity = fi.GetAccessControl(); // Allow Users to Write. //SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null); //fileSecurity.AddAccessRule(new FileSystemAccessRule(sid, FileSystemRights.Write, AccessControlType.Allow)); //fi.SetAccessControl(fileSecurity); var rules = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); string message = string.Empty; foreach (var myacc in rules) { var acc = (FileSystemAccessRule)myacc; message += string.Format("IdentityReference: {0}\r\n", acc.IdentityReference.Value); message += string.Format("Access Control Type: {0}\r\n", acc.AccessControlType.ToString()); message += string.Format("\t{0}\r\n", acc.FileSystemRights.ToString()); //if ((acc.FileSystemRights & FileSystemRights.FullControl) == FileSystemRights.FullControl) //{ // Console.Write("FullControl"); //} //if ((acc.FileSystemRights & FileSystemRights.ReadData) == FileSystemRights.ReadData) //{ // Console.Write("ReadData"); //} //if ((acc.FileSystemRights & FileSystemRights.WriteData) == FileSystemRights.WriteData) //{ // Console.Write("WriteData"); //} //if ((acc.FileSystemRights & FileSystemRights.ListDirectory) == FileSystemRights.ListDirectory) //{ // Console.Write("ListDirectory"); //} //if ((acc.FileSystemRights & FileSystemRights.ExecuteFile) == FileSystemRights.ExecuteFile) //{ // Console.Write("ExecuteFile"); //} } MessageBox.Show(message); //WindowsIdentity self = System.Security.Principal.WindowsIdentity.GetCurrent(); // FileSystemAccessRule rule = new FileSystemAccessRule( // self.Name, // FileSystemRights.FullControl, // AccessControlType.Allow); }
static public int GetAccessControl(IntPtr l) { try { System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l); var ret = self.GetAccessControl(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
static public int GetAccessControl__AccessControlSections(IntPtr l) { try { System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l); System.Security.AccessControl.AccessControlSections a1; checkEnum(l, 2, out a1); var ret = self.GetAccessControl(a1); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
/// <summary> /// Tao file dang text: doc, txt, html /// </summary> /// <param name="path">duong dan url</param> /// <param name="value">noi dung file</param> public static void WriteFile(string path, string value) { FileStream stream = null; try { stream = new FileStream(path, FileMode.Create); using (StreamWriter _sw = new StreamWriter(stream, Encoding.UTF8)) { _sw.WriteLine(value); stream = null; } } finally { if (stream != null) { stream.Dispose(); } } try { System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(path); // Get a DirectorySecurity object that represents the // current security settings. DirectorySecurity dSecurity = dInfo.GetAccessControl(); // Add the FileSystemAccessRule to the security settings. dSecurity.AddAccessRule( new FileSystemAccessRule( new System.Security.Principal.NTAccount("Everyone"), FileSystemRights.DeleteSubdirectoriesAndFiles, AccessControlType.Allow ) ); // Set the new access settings. dInfo.SetAccessControl(dSecurity); } catch (Exception ex) { Console.Write(ex.Message); } }
static void Main(string[] args) { if (args.Length == 1 && args[0] == "INSTALLER") { System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); FileSystemAccessRule fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow); DirectorySecurity ds = null; ds = di.GetAccessControl(); ds.AddAccessRule(fsar); di.SetAccessControl(ds); Process.Start(Application.ExecutablePath); return; } Thread.Sleep(2000); Process[] runningProcesses = Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName); if (runningProcesses.Length == 1 || (args.Length == 1 && args[0] == "OVERRIDE_PROCESS_CHECK")) // if its just me or OVERRIDE is set, let me run! { //systray icon config components = new System.ComponentModel.Container(); trayIcon = new NotifyIcon(components) { ContextMenuStrip = new ContextMenuStrip(), Icon = amber, Text = "PersistentHotspot loading..", Visible = true }; trayIcon.ContextMenuStrip.Opening += ContextMenuStrip_Opening; trayIcon.MouseUp += trayIcon_MouseUp; if (Reg.auto_restart_hotspot > 0) { timeWatch.Restart(); } //Monitor hotspot thread var task = MonitorHotspot(); HandleException(task); Updater.Run("PersistentHotspot"); Application.Run(); } }
public static DirectoryInfo GetOrCreateSessionTempFolder(string SessionID) { try { string tmpPath = System.IO.Path.Combine(GetOrCreateApplicationTempFolder().FullName, SessionID); System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(tmpPath); if (!tmpPathDirInfo.Exists) { tmpPathDirInfo.Create(); System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl(); dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow)); tmpPathDirInfo.SetAccessControl(dSecurity); } return(tmpPathDirInfo); } catch { } return(new DirectoryInfo(System.IO.Path.GetTempPath())); }
static void Main(string[] args) { if (args.Length == 1 && args[0] == "INSTALLER") { System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); FileSystemAccessRule fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow); DirectorySecurity ds = null; ds = di.GetAccessControl(); ds.AddAccessRule(fsar); di.SetAccessControl(ds); Process.Start(Application.ExecutablePath); return; } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new NmapMT()); }
public static void ClearApplicationTempFolder() { string tmpFolder = GetDefaultApplicationTempFolder(); if (System.IO.Directory.Exists(tmpFolder)) { try { System.IO.Directory.Delete(tmpFolder, true); } catch (System.Security.SecurityException) { System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(tmpFolder); System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl(); try { bool tryModify = false; dSecurity.ModifyAccessRule(System.Security.AccessControl.AccessControlModification.Reset, new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow), out tryModify); if (tryModify) { tmpPathDirInfo.SetAccessControl(dSecurity); tmpPathDirInfo.Delete(true); } else { dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow)); tmpPathDirInfo.SetAccessControl(dSecurity); tmpPathDirInfo.Delete(true); } } catch { } } catch { } } }
public static void _report(string TAG, string logtxt) { try { var logfolder = AppDomain.CurrentDomain.BaseDirectory + "\\Log\\Report"; System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(logfolder); FileSystemAccessRule fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow); DirectorySecurity ds = null; if (!di.Exists) { Directory.CreateDirectory(logfolder); } ds = di.GetAccessControl(); ds.AddAccessRule(fsar); StreamWriter sw = new StreamWriter(logfolder + "\\report" + DateTime.Today.ToString("yyyyMMdd") + ".txt", true); sw.WriteLine(string.Format(@"{0} [{1}] {2}", DateTime.Now.ToString(ConstantValues.FORMAT_DATE_TIME_MILISECONDS), TAG, logtxt)); sw.Close(); logtxt = string.Empty; } catch (Exception ex) { ex.ToString(); } }
/// <summary> /// Gets a System.Security.AccessControl.DirectorySecurity object that encapsulates /// the access control list (ACL) entries for the directory described by the /// current System.IO.DirectoryInfo object. /// </summary> /// <returns> /// A System.Security.AccessControl.DirectorySecurity object that encapsulates /// the access control rules for the directory. /// </returns> /// <exception cref="System.SystemException"> /// The directory could not be found or modified. /// </exception> /// <exception cref="System.UnauthorizedAccessException"> /// The current process does not have access to open the directory. /// </exception> /// <exception cref="System.IO.IOException"> /// An I/O error occurred while opening the directory. /// </exception> /// <exception cref="System.PlatformNotSupportedException"> /// The current operating system is not Microsoft Windows 2000 or later. /// </exception> /// <exception cref="System.UnauthorizedAccessException"> /// The directory is read-only.-or- This operation is not supported on the current /// platform.-or- The caller does not have the required permission. /// </exception> public DirectorySecurity GetAccessControl() { return(_directoryInfo.GetAccessControl()); }
public void CompressFile() { //int waitTime; frmmain.currentCopyFile = "Prepare to create a Android Book..."; ExportAPK("d"); if (Directory.Exists(Path.Combine(Application.StartupPath, "tool\\book")) == false) { frmmain.completeCompile = false; MessageBox.Show("کتابساز با خطا مواجه شد.خطا ممکن است از اجرای نرم افزار جاوا باشد.\nلطفا نرم افزار را فعال و یا دوباره نصب کنید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } string xmlPath = Path.Combine(Application.StartupPath, "tool\\book\\AndroidManifest.xml"); #region Permission try { frmmain.currentCopyFile = "Change Permission Folder"; Thread.Sleep(300); System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(Path.Combine(Application.StartupPath, "tool\\book")); // Get a DirectorySecurity object that represents the // current security settings. DirectorySecurity dSecurity = dInfo.GetAccessControl(); // Add the FileSystemAccessRule to the security settings. dSecurity.AddAccessRule( new FileSystemAccessRule( new System.Security.Principal.SecurityIdentifier( System.Security.Principal.WellKnownSidType.BuiltinUsersSid, null ), FileSystemRights.DeleteSubdirectoriesAndFiles, //FileSystemRights.FullControl, AccessControlType.Allow ) ); // Set the new access settings. dInfo.SetAccessControl(dSecurity); } catch (Exception e2) { File.AppendAllText(Application.StartupPath + "\\log.txt", e2.Message + "\r\n"); } #endregion try { foreach (string file in files) { try { if (file.EndsWith("Thumbs.db")) { continue; } File.Copy(file, Path.Combine(Path.Combine(Application.StartupPath, "tool\\book\\assets"), new FileInfo(file).Name), true); frmmain.currentCopyFile = file; } catch (Exception e1) { frmmain.completeCompile = false; File.AppendAllText(Application.StartupPath + "\\log.txt", e1.Message + "\r\n"); return; } Application.DoEvents(); } if (Directory.Exists(Application.StartupPath + "\\" + sProjectName + "\\lib")) { string[] Libfile = Directory.GetFiles(Application.StartupPath + "\\" + sProjectName + "\\lib"); foreach (string Libfile1 in Libfile) { try { File.Copy(Libfile1, Path.Combine(Application.StartupPath + "\\tool\\book\\assets", new FileInfo(Libfile1).Name), true); frmmain.currentCopyFile = "Copy Library File: " + Libfile1; Thread.Sleep(300); } catch (Exception e1) { File.AppendAllText(Application.StartupPath + "\\log.txt", e1.Message + "\r\n"); } Application.DoEvents(); } } if (File.Exists(Path.Combine(Application.StartupPath + "\\" + sProjectName, "icon.png"))) { File.Copy(Path.Combine(Application.StartupPath + "\\" + sProjectName, "icon.png"), Path.Combine(Application.StartupPath + "\\tool\\book\\res\\drawable", "icon.png"), true); frmmain.currentCopyFile = Application.StartupPath + "\\" + sProjectName + "\\icon.png"; } if (TypeBook == 1) { File.WriteAllText(Application.StartupPath + "\\tool\\book\\assets\\short_book", ""); } #region write manifest file XmlDocument doc = new XmlDocument(); doc.Load(Path.Combine(Application.StartupPath + "\\tool\\book", "AndroidManifest.xml")); if (sVersions.Length < 3) { sVersions = "1.0.0"; } XmlNode versionNode = doc.SelectSingleNode(@"manifest"); versionNode.Attributes["package"].InnerText = "student." + sProjectName; versionNode.Attributes["android:versionName"].InnerText = sVersions; versionNode.Attributes["android:versionCode"].InnerText = sVersions.Substring(0, 1); XmlNode LabelNode1 = doc.SelectSingleNode(@"manifest/application"); LabelNode1.Attributes["android:label"].InnerText = sBookNames; XmlNodeList Activities = doc.SelectSingleNode(@"manifest/application").ChildNodes; for (int i = 0; i < Activities.Count; i++) { XmlNode x1 = Activities[i]; if (x1.Name.ToLower() == "activity") { try { x1.Attributes["android:label"].InnerText = sBookNames; } catch (Exception) { } } } doc.Save(Path.Combine(Application.StartupPath + "\\tool\\book", "AndroidManifest.xml")); #endregion Directory.Move(Application.StartupPath + "\\tool\\book\\smali\\student\\templatebook", Application.StartupPath + "\\tool\\book\\smali\\student\\" + sProjectName); frmmain.currentCopyFile = "Change Book Package Name"; changeAPKPackage(sProjectName); frmmain.currentCopyFile = "Starting Compile..."; ExportAPK("b"); File.Copy(Application.StartupPath + "\\tool\\book\\dist\\book.apk", Application.StartupPath + "\\tool\\output\\book_out.apk", true); Directory.Delete(Application.StartupPath + "\\tool\\book", true); SignAPK(); File.Delete(Application.StartupPath + "\\tool\\output\\book_out.apk"); //Thread.Sleep(waitTime); frmmain.completeCompile = true; myClass.clearFolder(Application.StartupPath + "\\tool\\book"); if (Directory.Exists(Application.StartupPath + "\\tool\\book")) { Directory.Delete(Application.StartupPath + "\\tool\\book"); } } catch (Exception) { frmmain.completeCompile = false; } }
// 点击安装按钮 private void btnBegin_Click(object sender, EventArgs e) { if (!chkAgreeLicense.Checked) { DialogForm.Show("系统提示", "需勾选同意用户许可协议。", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } string targetPath = txtInstallPath.Text; try { // 1.检测路径 Directory.CreateDirectory(targetPath); // 设置权限 System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(targetPath); FileSystemAccessRule fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow); DirectorySecurity ds = di.GetAccessControl(); ds.AddAccessRule(fsar); di.SetAccessControl(ds); InstallDir = targetPath; // 反安装记录 this.uninstInfo.DestDir = targetPath; this.uninstInfo.Manifest = new List <InstalledFiles>(); // 1.1检测zip文件 string zipfile = "Release.zip"; if (!System.IO.File.Exists(zipfile)) { DialogForm.Show("系统提示", "安装包不完整, 操作中止。"); try { Directory.Delete(targetPath); } catch { } return; } // 2.开始 HideFirstPage(); ShowSecendPage(); // 2.1解压到目标 ExtractFile(zipfile, targetPath); } catch (UnauthorizedAccessException uacEx) { logger.Error(uacEx.StackTrace); DialogForm.Show("系统提示", "无法将文件安装到你选定的目录,请尝试用管理员身份运行。"); } catch (Exception ex) { logger.Error(ex.StackTrace); DialogForm.Show("系统提示", "无法将文件安装到你选定的目录,请检查路径是否正确或者是否拥有写权限。"); } }
public System.Security.AccessControl.DirectorySecurity GetAccessControl() { return(inner.GetAccessControl()); }
public static void Add(string Path, string UserName, FileSystemRights Role) { DirectoryInfo dirinfo = new DirectoryInfo(Path); DirectorySecurity sec = dirinfo.GetAccessControl(); sec.AddAccessRule(new FileSystemAccessRule(UserName, Role, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); dirinfo.SetAccessControl(sec); }