Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / 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
- ArraySortHelper.cs
- Registry.cs
- XmlEncodedRawTextWriter.cs
- WebPartConnectionsConnectVerb.cs
- SignatureGenerator.cs
- CodeTypeReferenceCollection.cs
- CurrentChangedEventManager.cs
- CustomTypeDescriptor.cs
- PointF.cs
- StrokeSerializer.cs
- List.cs
- XmlTextAttribute.cs
- UnsafeNativeMethods.cs
- PatternMatcher.cs
- activationcontext.cs
- StrongNameIdentityPermission.cs
- PropertyDescriptorComparer.cs
- SiteMapProvider.cs
- GenericTypeParameterBuilder.cs
- SqlDataSourceEnumerator.cs
- WebPartPersonalization.cs
- TextTreeInsertElementUndoUnit.cs
- ExpressionWriter.cs
- FormsIdentity.cs
- Route.cs
- DataBinding.cs
- ProfileInfo.cs
- EventLogPermission.cs
- DataGridRow.cs
- ConnectionStringSettings.cs
- VirtualDirectoryMapping.cs
- CommonObjectSecurity.cs
- ModelChangedEventArgsImpl.cs
- DataGridHeaderBorder.cs
- HandleExceptionArgs.cs
- MiniConstructorInfo.cs
- XmlSchemaInferenceException.cs
- TrustManager.cs
- DefaultProxySection.cs
- SiteMembershipCondition.cs
- DbDataAdapter.cs
- LinkButton.cs
- TypeRefElement.cs
- ApplicationTrust.cs
- PerformanceCounterPermission.cs
- HttpWebRequestElement.cs
- SerializationIncompleteException.cs
- XmlBinaryReader.cs
- ConnectionPointGlyph.cs
- GridEntryCollection.cs
- MethodBuilderInstantiation.cs
- ElementNotAvailableException.cs
- PolyQuadraticBezierSegment.cs
- CreateWorkflowOwnerCommand.cs
- UInt32Converter.cs
- InfoCardRSAOAEPKeyExchangeDeformatter.cs
- RoleGroup.cs
- LabelLiteral.cs
- DataContractSet.cs
- TreeViewAutomationPeer.cs
- CodeAttributeDeclarationCollection.cs
- BitStream.cs
- DoubleCollection.cs
- LineVisual.cs
- XmlQualifiedNameTest.cs
- DataControlField.cs
- SmiSettersStream.cs
- SimpleRecyclingCache.cs
- HighlightComponent.cs
- MasterPage.cs
- Int16.cs
- DiscoveryClientElement.cs
- SamlAuthorizationDecisionClaimResource.cs
- ExpressionBindingsDialog.cs
- SamlAssertionKeyIdentifierClause.cs
- AppDomainManager.cs
- DataServicePagingProviderWrapper.cs
- EndpointReference.cs
- ProfileServiceManager.cs
- DataBinding.cs
- cache.cs
- XmlTextReaderImpl.cs
- linebase.cs
- _AutoWebProxyScriptEngine.cs
- DeferredSelectedIndexReference.cs
- PhysicalAddress.cs
- InstanceDescriptor.cs
- TagPrefixInfo.cs
- ReadOnlyDataSourceView.cs
- SizeAnimationClockResource.cs
- ReturnEventArgs.cs
- BridgeDataReader.cs
- PeerCollaboration.cs
- BulletedList.cs
- AccessDataSourceView.cs
- HtmlInputHidden.cs
- GenericIdentity.cs
- RelatedCurrencyManager.cs
- Color.cs
- ContainerControl.cs