Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / clr / src / BCL / System / Security / AccessControl / FileSecurity.cs / 1 / FileSecurity.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*============================================================
**
** Class: FileSecurity
**
**
** Purpose: Managed ACL wrapper for files & directories.
**
**
===========================================================*/
using System;
using System.Collections;
using System.Security.AccessControl;
using System.Security.Permissions;
using System.Security.Principal;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
using System.Runtime.InteropServices;
using System.IO;
using System.Runtime.Versioning;
namespace System.Security.AccessControl
{
// Constants from from winnt.h - search for FILE_WRITE_DATA, etc.
[Flags]
public enum FileSystemRights
{
// No None field - An ACE with the value 0 cannot grant nor deny.
ReadData = 0x000001,
ListDirectory = ReadData, // For directories
WriteData = 0x000002,
CreateFiles = WriteData, // For directories
AppendData = 0x000004,
CreateDirectories = AppendData, // For directories
ReadExtendedAttributes = 0x000008,
WriteExtendedAttributes = 0x000010,
ExecuteFile = 0x000020, // For files
Traverse = ExecuteFile, // For directories
// DeleteSubdirectoriesAndFiles only makes sense on directories, but
// the shell explicitly sets it for files in its UI. So we'll include
// it in FullControl.
DeleteSubdirectoriesAndFiles = 0x000040,
ReadAttributes = 0x000080,
WriteAttributes = 0x000100,
Delete = 0x010000,
ReadPermissions = 0x020000,
ChangePermissions = 0x040000,
TakeOwnership = 0x080000,
// From the Core File Services team, CreateFile always requires
// SYNCHRONIZE access. Very tricksy, CreateFile is.
Synchronize = 0x100000, // Can we wait on the handle?
FullControl = 0x1F01FF,
// These map to what Explorer sets, and are what most users want.
// However, an ACL editor will also want to set the Synchronize
// bit when allowing access, and exclude the synchronize bit when
// denying access.
Read = ReadData | ReadExtendedAttributes | ReadAttributes | ReadPermissions,
ReadAndExecute = Read | ExecuteFile,
Write = WriteData | AppendData | WriteExtendedAttributes | WriteAttributes,
Modify = ReadAndExecute | Write | Delete,
}
public sealed class FileSystemAccessRule : AccessRule
{
#region Constructors
//
// Constructor for creating access rules for file objects
//
public FileSystemAccessRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
AccessControlType type )
: this(
identity,
AccessMaskFromRights( fileSystemRights, type ),
false,
InheritanceFlags.None,
PropagationFlags.None,
type )
{
}
public FileSystemAccessRule(
String identity,
FileSystemRights fileSystemRights,
AccessControlType type )
: this(
new NTAccount(identity),
AccessMaskFromRights( fileSystemRights, type ),
false,
InheritanceFlags.None,
PropagationFlags.None,
type )
{
}
//
// Constructor for creating access rules for folder objects
//
public FileSystemAccessRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AccessControlType type )
: this(
identity,
AccessMaskFromRights( fileSystemRights, type ),
false,
inheritanceFlags,
propagationFlags,
type )
{
}
public FileSystemAccessRule(
String identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AccessControlType type )
: this(
new NTAccount(identity),
AccessMaskFromRights( fileSystemRights, type ),
false,
inheritanceFlags,
propagationFlags,
type )
{
}
//
// Internal constructor to be called by public constructors
// and the access rule factory methods of {File|Folder}Security
//
internal FileSystemAccessRule(
IdentityReference identity,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AccessControlType type )
: base(
identity,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
type )
{
}
#endregion
#region Public properties
public FileSystemRights FileSystemRights
{
get { return RightsFromAccessMask( base.AccessMask ); }
}
#endregion
#region Access mask to rights translation
// ACL's on files have a SYNCHRONIZE bit, and CreateFile ALWAYS
// asks for it. So for allows, let's always include this bit,
// and for denies, let's never include this bit unless we're denying
// full control. This is the right thing for users, even if it does
// make the model look asymmetrical from a purist point of view.
internal static int AccessMaskFromRights( FileSystemRights fileSystemRights, AccessControlType controlType )
{
if (fileSystemRights < (FileSystemRights) 0 || fileSystemRights > FileSystemRights.FullControl)
throw new ArgumentOutOfRangeException("fileSystemRights", Environment.GetResourceString("Argument_InvalidEnumValue", fileSystemRights, "FileSystemRights"));
if (controlType == AccessControlType.Allow) {
fileSystemRights |= FileSystemRights.Synchronize;
}
else if (controlType == AccessControlType.Deny) {
if (fileSystemRights != FileSystemRights.FullControl &&
fileSystemRights != (FileSystemRights.FullControl & ~FileSystemRights.DeleteSubdirectoriesAndFiles))
fileSystemRights &= ~FileSystemRights.Synchronize;
}
return ( int )fileSystemRights;
}
internal static FileSystemRights RightsFromAccessMask( int accessMask )
{
return ( FileSystemRights )accessMask;
}
#endregion
}
public sealed class FileSystemAuditRule : AuditRule
{
#region Constructors
public FileSystemAuditRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
AuditFlags flags )
: this(
identity,
fileSystemRights,
InheritanceFlags.None,
PropagationFlags.None,
flags )
{
}
public FileSystemAuditRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: this(
identity,
AccessMaskFromRights( fileSystemRights ),
false,
inheritanceFlags,
propagationFlags,
flags )
{
}
public FileSystemAuditRule(
String identity,
FileSystemRights fileSystemRights,
AuditFlags flags )
: this(
new NTAccount(identity),
fileSystemRights,
InheritanceFlags.None,
PropagationFlags.None,
flags )
{
}
public FileSystemAuditRule(
String identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: this(
new NTAccount(identity),
AccessMaskFromRights( fileSystemRights ),
false,
inheritanceFlags,
propagationFlags,
flags )
{
}
internal FileSystemAuditRule(
IdentityReference identity,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: base(
identity,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
flags )
{
}
#endregion
#region Private methods
private static int AccessMaskFromRights( FileSystemRights fileSystemRights )
{
if (fileSystemRights < (FileSystemRights) 0 || fileSystemRights > FileSystemRights.FullControl)
throw new ArgumentOutOfRangeException("fileSystemRights", Environment.GetResourceString("Argument_InvalidEnumValue", fileSystemRights, "FileSystemRights"));
return ( int )fileSystemRights;
}
#endregion
#region Public properties
public FileSystemRights FileSystemRights
{
get { return FileSystemAccessRule.RightsFromAccessMask( base.AccessMask ); }
}
#endregion
}
public abstract class FileSystemSecurity : NativeObjectSecurity
{
#region Member variables
private const ResourceType s_ResourceType = ResourceType.FileObject;
#endregion
internal FileSystemSecurity( bool isContainer )
: base(isContainer, s_ResourceType, _HandleErrorCode, isContainer)
{
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
internal FileSystemSecurity( bool isContainer, String name, AccessControlSections includeSections, bool isDirectory )
: base( isContainer, s_ResourceType, name, includeSections, _HandleErrorCode, isDirectory )
{
}
internal FileSystemSecurity( bool isContainer, SafeFileHandle handle, AccessControlSections includeSections, bool isDirectory )
: base( isContainer, s_ResourceType, handle, includeSections, _HandleErrorCode, isDirectory )
{
}
private static Exception _HandleErrorCode(int errorCode, string name, SafeHandle handle, object context)
{
System.Exception exception = null;
switch (errorCode) {
case Win32Native.ERROR_INVALID_NAME:
exception = new ArgumentException(Environment.GetResourceString("Argument_InvalidName"),"name");
break;
case Win32Native.ERROR_INVALID_HANDLE:
exception = new ArgumentException(Environment.GetResourceString("AccessControl_InvalidHandle"));
break;
case Win32Native.ERROR_FILE_NOT_FOUND:
if ((context != null) && (context is bool) && ((bool)context)) { // DirectorySecurity
if ((name != null) && (name.Length != 0))
exception = new DirectoryNotFoundException(name);
else
exception = new DirectoryNotFoundException();
}
else {
if ((name != null) && (name.Length != 0))
exception = new FileNotFoundException(name);
else
exception = new FileNotFoundException();
}
break;
default:
break;
}
return exception;
}
#region Factories
public sealed override AccessRule AccessRuleFactory(
IdentityReference identityReference,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AccessControlType type )
{
return new FileSystemAccessRule(
identityReference,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
type );
}
public sealed override AuditRule AuditRuleFactory(
IdentityReference identityReference,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
{
return new FileSystemAuditRule(
identityReference,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
flags );
}
#endregion
#region Internal Methods
internal AccessControlSections GetAccessControlSectionsFromChanges()
{
AccessControlSections persistRules = AccessControlSections.None;
if ( AccessRulesModified )
persistRules = AccessControlSections.Access;
if ( AuditRulesModified )
persistRules |= AccessControlSections.Audit;
if ( OwnerModified )
persistRules |= AccessControlSections.Owner;
if ( GroupModified )
persistRules |= AccessControlSections.Group;
return persistRules;
}
[SecurityPermission(SecurityAction.Assert, UnmanagedCode=true)]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
internal void Persist( String fullPath )
{
new FileIOPermission( FileIOPermissionAccess.NoAccess, AccessControlActions.Change, fullPath ).Demand();
WriteLock();
try
{
AccessControlSections persistRules = GetAccessControlSectionsFromChanges();
base.Persist( fullPath, persistRules );
OwnerModified = GroupModified = AuditRulesModified = AccessRulesModified = false;
}
finally
{
WriteUnlock();
}
}
[SecurityPermission(SecurityAction.Assert, UnmanagedCode=true)]
internal void Persist( SafeFileHandle handle, String fullPath )
{
if ( fullPath != null )
new FileIOPermission( FileIOPermissionAccess.NoAccess, AccessControlActions.Change, fullPath ).Demand();
else
new FileIOPermission( PermissionState.Unrestricted ).Demand();
WriteLock();
try
{
AccessControlSections persistRules = GetAccessControlSectionsFromChanges();
base.Persist( handle, persistRules );
OwnerModified = GroupModified = AuditRulesModified = AccessRulesModified = false;
}
finally
{
WriteUnlock();
}
}
#endregion
#region Public Methods
public void AddAccessRule( FileSystemAccessRule rule )
{
base.AddAccessRule( rule );
//PersistIfPossible();
}
public void SetAccessRule( FileSystemAccessRule rule )
{
base.SetAccessRule( rule );
}
public void ResetAccessRule( FileSystemAccessRule rule )
{
base.ResetAccessRule( rule );
}
public bool RemoveAccessRule( FileSystemAccessRule rule )
{
if ( rule == null )
throw new ArgumentNullException("rule");
// If the rule to be removed matches what is there currently then
// remove it unaltered. That is, don't mask off the Synchronize bit.
// This is to avoid dangling synchronize bit
AuthorizationRuleCollection rules = GetAccessRules(true, true, rule.IdentityReference.GetType());
for (int i=0; i FileSystemRights.FullControl)
throw new ArgumentOutOfRangeException("fileSystemRights", Environment.GetResourceString("Argument_InvalidEnumValue", fileSystemRights, "FileSystemRights"));
if (controlType == AccessControlType.Allow) {
fileSystemRights |= FileSystemRights.Synchronize;
}
else if (controlType == AccessControlType.Deny) {
if (fileSystemRights != FileSystemRights.FullControl &&
fileSystemRights != (FileSystemRights.FullControl & ~FileSystemRights.DeleteSubdirectoriesAndFiles))
fileSystemRights &= ~FileSystemRights.Synchronize;
}
return ( int )fileSystemRights;
}
internal static FileSystemRights RightsFromAccessMask( int accessMask )
{
return ( FileSystemRights )accessMask;
}
#endregion
}
public sealed class FileSystemAuditRule : AuditRule
{
#region Constructors
public FileSystemAuditRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
AuditFlags flags )
: this(
identity,
fileSystemRights,
InheritanceFlags.None,
PropagationFlags.None,
flags )
{
}
public FileSystemAuditRule(
IdentityReference identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: this(
identity,
AccessMaskFromRights( fileSystemRights ),
false,
inheritanceFlags,
propagationFlags,
flags )
{
}
public FileSystemAuditRule(
String identity,
FileSystemRights fileSystemRights,
AuditFlags flags )
: this(
new NTAccount(identity),
fileSystemRights,
InheritanceFlags.None,
PropagationFlags.None,
flags )
{
}
public FileSystemAuditRule(
String identity,
FileSystemRights fileSystemRights,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: this(
new NTAccount(identity),
AccessMaskFromRights( fileSystemRights ),
false,
inheritanceFlags,
propagationFlags,
flags )
{
}
internal FileSystemAuditRule(
IdentityReference identity,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
: base(
identity,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
flags )
{
}
#endregion
#region Private methods
private static int AccessMaskFromRights( FileSystemRights fileSystemRights )
{
if (fileSystemRights < (FileSystemRights) 0 || fileSystemRights > FileSystemRights.FullControl)
throw new ArgumentOutOfRangeException("fileSystemRights", Environment.GetResourceString("Argument_InvalidEnumValue", fileSystemRights, "FileSystemRights"));
return ( int )fileSystemRights;
}
#endregion
#region Public properties
public FileSystemRights FileSystemRights
{
get { return FileSystemAccessRule.RightsFromAccessMask( base.AccessMask ); }
}
#endregion
}
public abstract class FileSystemSecurity : NativeObjectSecurity
{
#region Member variables
private const ResourceType s_ResourceType = ResourceType.FileObject;
#endregion
internal FileSystemSecurity( bool isContainer )
: base(isContainer, s_ResourceType, _HandleErrorCode, isContainer)
{
}
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
internal FileSystemSecurity( bool isContainer, String name, AccessControlSections includeSections, bool isDirectory )
: base( isContainer, s_ResourceType, name, includeSections, _HandleErrorCode, isDirectory )
{
}
internal FileSystemSecurity( bool isContainer, SafeFileHandle handle, AccessControlSections includeSections, bool isDirectory )
: base( isContainer, s_ResourceType, handle, includeSections, _HandleErrorCode, isDirectory )
{
}
private static Exception _HandleErrorCode(int errorCode, string name, SafeHandle handle, object context)
{
System.Exception exception = null;
switch (errorCode) {
case Win32Native.ERROR_INVALID_NAME:
exception = new ArgumentException(Environment.GetResourceString("Argument_InvalidName"),"name");
break;
case Win32Native.ERROR_INVALID_HANDLE:
exception = new ArgumentException(Environment.GetResourceString("AccessControl_InvalidHandle"));
break;
case Win32Native.ERROR_FILE_NOT_FOUND:
if ((context != null) && (context is bool) && ((bool)context)) { // DirectorySecurity
if ((name != null) && (name.Length != 0))
exception = new DirectoryNotFoundException(name);
else
exception = new DirectoryNotFoundException();
}
else {
if ((name != null) && (name.Length != 0))
exception = new FileNotFoundException(name);
else
exception = new FileNotFoundException();
}
break;
default:
break;
}
return exception;
}
#region Factories
public sealed override AccessRule AccessRuleFactory(
IdentityReference identityReference,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AccessControlType type )
{
return new FileSystemAccessRule(
identityReference,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
type );
}
public sealed override AuditRule AuditRuleFactory(
IdentityReference identityReference,
int accessMask,
bool isInherited,
InheritanceFlags inheritanceFlags,
PropagationFlags propagationFlags,
AuditFlags flags )
{
return new FileSystemAuditRule(
identityReference,
accessMask,
isInherited,
inheritanceFlags,
propagationFlags,
flags );
}
#endregion
#region Internal Methods
internal AccessControlSections GetAccessControlSectionsFromChanges()
{
AccessControlSections persistRules = AccessControlSections.None;
if ( AccessRulesModified )
persistRules = AccessControlSections.Access;
if ( AuditRulesModified )
persistRules |= AccessControlSections.Audit;
if ( OwnerModified )
persistRules |= AccessControlSections.Owner;
if ( GroupModified )
persistRules |= AccessControlSections.Group;
return persistRules;
}
[SecurityPermission(SecurityAction.Assert, UnmanagedCode=true)]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
internal void Persist( String fullPath )
{
new FileIOPermission( FileIOPermissionAccess.NoAccess, AccessControlActions.Change, fullPath ).Demand();
WriteLock();
try
{
AccessControlSections persistRules = GetAccessControlSectionsFromChanges();
base.Persist( fullPath, persistRules );
OwnerModified = GroupModified = AuditRulesModified = AccessRulesModified = false;
}
finally
{
WriteUnlock();
}
}
[SecurityPermission(SecurityAction.Assert, UnmanagedCode=true)]
internal void Persist( SafeFileHandle handle, String fullPath )
{
if ( fullPath != null )
new FileIOPermission( FileIOPermissionAccess.NoAccess, AccessControlActions.Change, fullPath ).Demand();
else
new FileIOPermission( PermissionState.Unrestricted ).Demand();
WriteLock();
try
{
AccessControlSections persistRules = GetAccessControlSectionsFromChanges();
base.Persist( handle, persistRules );
OwnerModified = GroupModified = AuditRulesModified = AccessRulesModified = false;
}
finally
{
WriteUnlock();
}
}
#endregion
#region Public Methods
public void AddAccessRule( FileSystemAccessRule rule )
{
base.AddAccessRule( rule );
//PersistIfPossible();
}
public void SetAccessRule( FileSystemAccessRule rule )
{
base.SetAccessRule( rule );
}
public void ResetAccessRule( FileSystemAccessRule rule )
{
base.ResetAccessRule( rule );
}
public bool RemoveAccessRule( FileSystemAccessRule rule )
{
if ( rule == null )
throw new ArgumentNullException("rule");
// If the rule to be removed matches what is there currently then
// remove it unaltered. That is, don't mask off the Synchronize bit.
// This is to avoid dangling synchronize bit
AuthorizationRuleCollection rules = GetAccessRules(true, true, rule.IdentityReference.GetType());
for (int i=0; i
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XamlFxTrace.cs
- BooleanExpr.cs
- AddIn.cs
- StreamReader.cs
- AddInAdapter.cs
- APCustomTypeDescriptor.cs
- PersonalizationStateInfoCollection.cs
- SQLResource.cs
- CornerRadius.cs
- KnownTypesProvider.cs
- CompiledIdentityConstraint.cs
- XmlValidatingReader.cs
- DataGridHelper.cs
- FieldToken.cs
- WebPart.cs
- AssemblyResourceLoader.cs
- KnownBoxes.cs
- PerformanceCountersElement.cs
- ConstraintManager.cs
- PersistChildrenAttribute.cs
- ResizeGrip.cs
- RenderOptions.cs
- CompositionTarget.cs
- CodeLinePragma.cs
- EntityCollection.cs
- Membership.cs
- ControlTemplate.cs
- BinaryObjectReader.cs
- OnOperation.cs
- XomlCompilerHelpers.cs
- Axis.cs
- ButtonBaseAdapter.cs
- SequenceNumber.cs
- XmlDomTextWriter.cs
- AccessDataSource.cs
- GridEntryCollection.cs
- BindingManagerDataErrorEventArgs.cs
- MenuAutomationPeer.cs
- ClientSession.cs
- ObservableCollectionDefaultValueFactory.cs
- ListViewItem.cs
- ProcessDesigner.cs
- ToolBar.cs
- EntityStoreSchemaFilterEntry.cs
- DependencyPropertyValueSerializer.cs
- PropertyInformation.cs
- DataTableExtensions.cs
- TableSectionStyle.cs
- ObjectTypeMapping.cs
- wmiprovider.cs
- RegistryKey.cs
- InfiniteTimeSpanConverter.cs
- RectangleGeometry.cs
- FacetValueContainer.cs
- HebrewNumber.cs
- InfoCardRSAOAEPKeyExchangeDeformatter.cs
- XamlTemplateSerializer.cs
- XmlNamespaceMapping.cs
- NetworkInterface.cs
- MessageAction.cs
- FixedStringLookup.cs
- XmlSchemaValidator.cs
- XmlSchemaSet.cs
- HtmlFormWrapper.cs
- Context.cs
- SqlMethods.cs
- COM2PropertyPageUITypeConverter.cs
- RootBuilder.cs
- PlatformNotSupportedException.cs
- ChildChangedEventArgs.cs
- XmlQueryCardinality.cs
- Int32CAMarshaler.cs
- SQLBytes.cs
- FamilyMap.cs
- RequiredArgumentAttribute.cs
- SqlParameter.cs
- Helpers.cs
- TextWriterTraceListener.cs
- SqlWorkflowPersistenceService.cs
- Types.cs
- ActivitySurrogateSelector.cs
- TextTreeObjectNode.cs
- UserThread.cs
- PointAnimation.cs
- LocationFactory.cs
- ChannelManager.cs
- WhitespaceRuleReader.cs
- webbrowsersite.cs
- AspNetCompatibilityRequirementsMode.cs
- SqlError.cs
- SamlAttribute.cs
- MatrixAnimationBase.cs
- WebPartEventArgs.cs
- SqlDataSourceConfigureSelectPanel.cs
- AttachedPropertyMethodSelector.cs
- ReadOnlyObservableCollection.cs
- PrintPreviewDialog.cs
- XmlSerializableServices.cs
- IntSecurity.cs
- CompiledIdentityConstraint.cs