using System;
using System.Security.Principal;
namespace System.Security.AccessControl
{
/// Represents the Windows access control security for a registry key. This class cannot be inherited.
// Token: 0x020004DD RID: 1245
public sealed class RegistrySecurity : NativeObjectSecurity
{
/// Gets the enumeration type that the class uses to represent access rights.
/// A object representing the enumeration.
// Token: 0x17000924 RID: 2340
// (get) Token: 0x06002E27 RID: 11815 RVA: 0x00094328 File Offset: 0x00092528
public override Type AccessRightType
{
get
{
return typeof(RegistryRights);
}
}
/// Gets the type that the class uses to represent access rules.
/// A object representing the class.
// Token: 0x17000925 RID: 2341
// (get) Token: 0x06002E28 RID: 11816 RVA: 0x00094334 File Offset: 0x00092534
public override Type AccessRuleType
{
get
{
return typeof(RegistryAccessRule);
}
}
/// Gets the type that the class uses to represent audit rules.
/// A object representing the class.
// Token: 0x17000926 RID: 2342
// (get) Token: 0x06002E29 RID: 11817 RVA: 0x00094340 File Offset: 0x00092540
public override Type AuditRuleType
{
get
{
return typeof(RegistryAuditRule);
}
}
/// Creates a new access control rule for the specified user, with the specified access rights, access control, and flags.
/// A object representing the specified rights for the specified user.
/// An that identifies the user or group the rule applies to.
/// A bitwise combination of values specifying the access rights to allow or deny, cast to an integer.
/// A Boolean value specifying whether the rule is inherited.
/// A bitwise combination of values specifying how the rule is inherited by subkeys.
/// A bitwise combination of values that modify the way the rule is inherited by subkeys. Meaningless if the value of is .
/// One of the values specifying whether the rights are allowed or denied.
///
/// , , , or specifies an invalid value.
///
/// is null. -or- is zero.
///
/// is neither of type , nor of a type such as that can be converted to type .
// Token: 0x06002E2A RID: 11818 RVA: 0x0009434C File Offset: 0x0009254C
public override AccessRule AccessRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type)
{
return new RegistryAccessRule(identityReference, (RegistryRights)accessMask, inheritanceFlags, propagationFlags, type);
}
/// Searches for a matching access control with which the new rule can be merged. If none are found, adds the new rule.
/// The access control rule to add.
///
/// is null.
// Token: 0x06002E2B RID: 11819 RVA: 0x0009435C File Offset: 0x0009255C
public void AddAccessRule(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Searches for an audit rule with which the new rule can be merged. If none are found, adds the new rule.
/// The audit rule to add. The user specified by this rule determines the search.
// Token: 0x06002E2C RID: 11820 RVA: 0x00094364 File Offset: 0x00092564
public void AddAuditRule(RegistryAuditRule rule)
{
throw new NotImplementedException();
}
/// Creates a new audit rule, specifying the user the rule applies to, the access rights to audit, the inheritance and propagation of the rule, and the outcome that triggers the rule.
/// A object representing the specified audit rule for the specified user, with the specified flags. The return type of the method is the base class, , but the return value can be cast safely to the derived class.
/// An that identifies the user or group the rule applies to.
/// A bitwise combination of values specifying the access rights to audit, cast to an integer.
/// A Boolean value specifying whether the rule is inherited.
/// A bitwise combination of values specifying how the rule is inherited by subkeys.
/// A bitwise combination of values that modify the way the rule is inherited by subkeys. Meaningless if the value of is .
/// A bitwise combination of values specifying whether to audit successful access, failed access, or both.
///
/// , , , or specifies an invalid value.
///
/// is null. -or- is zero.
///
/// is neither of type , nor of a type such as that can be converted to type .
// Token: 0x06002E2D RID: 11821 RVA: 0x0009436C File Offset: 0x0009256C
public override AuditRule AuditRuleFactory(IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags)
{
return new RegistryAuditRule(identityReference, (RegistryRights)accessMask, inheritanceFlags, propagationFlags, flags);
}
/// Searches for an access control rule with the same user and (allow or deny) as the specified access rule, and with compatible inheritance and propagation flags; if such a rule is found, the rights contained in the specified access rule are removed from it.
/// true if a compatible rule is found; otherwise false.
/// A that specifies the user and to search for, and a set of inheritance and propagation flags that a matching rule, if found, must be compatible with. Specifies the rights to remove from the compatible rule, if found.
///
/// is null.
// Token: 0x06002E2E RID: 11822 RVA: 0x0009437C File Offset: 0x0009257C
public bool RemoveAccessRule(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Searches for all access control rules with the same user and (allow or deny) as the specified rule and, if found, removes them.
/// A that specifies the user and to search for. Any rights, inheritance flags, or propagation flags specified by this rule are ignored.
///
/// is null.
// Token: 0x06002E2F RID: 11823 RVA: 0x00094384 File Offset: 0x00092584
public void RemoveAccessRuleAll(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Searches for an access control rule that exactly matches the specified rule and, if found, removes it.
/// The to remove.
///
/// is null.
// Token: 0x06002E30 RID: 11824 RVA: 0x0009438C File Offset: 0x0009258C
public void RemoveAccessRuleSpecific(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Searches for an audit control rule with the same user as the specified rule, and with compatible inheritance and propagation flags; if a compatible rule is found, the rights contained in the specified rule are removed from it.
/// true if a compatible rule is found; otherwise, false.
/// A that specifies the user to search for, and a set of inheritance and propagation flags that a matching rule, if found, must be compatible with. Specifies the rights to remove from the compatible rule, if found.
///
/// is null.
// Token: 0x06002E31 RID: 11825 RVA: 0x00094394 File Offset: 0x00092594
public bool RemoveAuditRule(RegistryAuditRule rule)
{
throw new NotImplementedException();
}
/// Searches for all audit rules with the same user as the specified rule and, if found, removes them.
/// A that specifies the user to search for. Any rights, inheritance flags, or propagation flags specified by this rule are ignored.
///
/// is null.
// Token: 0x06002E32 RID: 11826 RVA: 0x0009439C File Offset: 0x0009259C
public void RemoveAuditRuleAll(RegistryAuditRule rule)
{
throw new NotImplementedException();
}
/// Searches for an audit rule that exactly matches the specified rule and, if found, removes it.
/// The to be removed.
///
/// is null.
// Token: 0x06002E33 RID: 11827 RVA: 0x000943A4 File Offset: 0x000925A4
public void RemoveAuditRuleSpecific(RegistryAuditRule rule)
{
throw new NotImplementedException();
}
/// Removes all access control rules with the same user as the specified rule, regardless of , and then adds the specified rule.
/// The to add. The user specified by this rule determines the rules to remove before this rule is added.
// Token: 0x06002E34 RID: 11828 RVA: 0x000943AC File Offset: 0x000925AC
public void ResetAccessRule(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Removes all access control rules with the same user and (allow or deny) as the specified rule, and then adds the specified rule.
/// The to add. The user and of this rule determine the rules to remove before this rule is added.
///
/// is null.
// Token: 0x06002E35 RID: 11829 RVA: 0x000943B4 File Offset: 0x000925B4
public void SetAccessRule(RegistryAccessRule rule)
{
throw new NotImplementedException();
}
/// Removes all audit rules with the same user as the specified rule, regardless of the value, and then adds the specified rule.
/// The to add. The user specified by this rule determines the rules to remove before this rule is added.
///
/// is null.
// Token: 0x06002E36 RID: 11830 RVA: 0x000943BC File Offset: 0x000925BC
public void SetAuditRule(RegistryAuditRule rule)
{
throw new NotImplementedException();
}
}
}