SecurityPermission.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Security / Permissions / SecurityPermission.cs / 1305376 / SecurityPermission.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// SecurityPermission.cs
// 
// [....] 
//
 
namespace System.Security.Permissions
{
    using System;
    using System.IO; 
    using System.Security.Util;
    using System.Text; 
    using System.Threading; 
    using System.Runtime.Remoting;
    using System.Security; 
    using System.Runtime.Serialization;
    using System.Reflection;
    using System.Globalization;
    using System.Diagnostics.Contracts; 

[Serializable] 
    [Flags] 
[System.Runtime.InteropServices.ComVisible(true)]
#if !FEATURE_CAS_POLICY 
    // The csharp compiler requires these types to be public, but they are not used elsewhere.
    [Obsolete("SecurityPermissionFlag is no longer accessible to application code.")]
#endif
    public enum SecurityPermissionFlag 
    {
        NoFlags = 0x00, 
        /* The following enum value is used in the EE (ASSERT_PERMISSION in security.cpp) 
         * Should this value change, make corresponding changes there
         */ 
        Assertion = 0x01,
        UnmanagedCode = 0x02,       // Update vm\Security.h if you change this !
        SkipVerification = 0x04,    // Update vm\Security.h if you change this !
        Execution = 0x08, 
        ControlThread = 0x10,
        ControlEvidence = 0x20, 
        ControlPolicy = 0x40, 
        SerializationFormatter = 0x80,
        ControlDomainPolicy = 0x100, 
        ControlPrincipal = 0x200,
        ControlAppDomain = 0x400,
        RemotingConfiguration = 0x800,
        Infrastructure = 0x1000, 
        BindingRedirects = 0x2000,
        AllFlags = 0x3fff, 
    } 

[System.Runtime.InteropServices.ComVisible(true)] 
    [Serializable]
    sealed public class SecurityPermission
           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
    { 
        private SecurityPermissionFlag m_flags;
 
        // 
        // Public Constructors
        // 

        public SecurityPermission(PermissionState state)
        {
            if (state == PermissionState.Unrestricted) 
            {
                SetUnrestricted( true ); 
            } 
            else if (state == PermissionState.None)
            { 
                SetUnrestricted( false );
                Reset();
            }
            else 
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState")); 
            } 
        }
 

        // SecurityPermission
        //
        public SecurityPermission(SecurityPermissionFlag flag) 
        {
            VerifyAccess(flag); 
 
            SetUnrestricted(false);
            m_flags = flag; 
        }


        //------------------------------------------------------ 
        //
        // PRIVATE AND PROTECTED MODIFIERS 
        // 
        //-----------------------------------------------------
 

        private void SetUnrestricted(bool unrestricted)
        {
            if (unrestricted) 
            {
                m_flags = SecurityPermissionFlag.AllFlags; 
            } 
        }
 
        private void Reset()
        {
            m_flags = SecurityPermissionFlag.NoFlags;
        } 

 
        public SecurityPermissionFlag Flags 
        {
            set 
            {
                VerifyAccess(value);

                m_flags = value; 
            }
 
            get 
            {
                return m_flags; 
            }
        }

        // 
        // CodeAccessPermission methods
        // 
 
       /*
         * IPermission interface implementation 
         */

        public override bool IsSubsetOf(IPermission target)
        { 
            if (target == null)
            { 
                return m_flags == 0; 
            }
 
            SecurityPermission operand = target as SecurityPermission;
            if (operand != null)
            {
                return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0; 
            }
            else 
            { 
                throw new
                    ArgumentException( 
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
                                     );
            }
 
        }
 
        public override IPermission Union(IPermission target) { 
            if (target == null) return(this.Copy());
            if (!VerifyType(target)) { 
                throw new
                    ArgumentException(
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
                                     ); 
            }
            SecurityPermission sp_target = (SecurityPermission) target; 
            if (sp_target.IsUnrestricted() || IsUnrestricted()) { 
                return(new SecurityPermission(PermissionState.Unrestricted));
            } 
            SecurityPermissionFlag flag_union = (SecurityPermissionFlag)(m_flags | sp_target.m_flags);
            return(new SecurityPermission(flag_union));
        }
 
        public override IPermission Intersect(IPermission target)
        { 
            if (target == null) 
                return null;
            else if (!VerifyType(target)) 
            {
                throw new
                    ArgumentException(
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) 
                                     );
            } 
 
            SecurityPermission operand = (SecurityPermission)target;
            SecurityPermissionFlag isectFlags = SecurityPermissionFlag.NoFlags; 

            if (operand.IsUnrestricted())
            {
                if (this.IsUnrestricted()) 
                    return new SecurityPermission(PermissionState.Unrestricted);
                else 
                    isectFlags = (SecurityPermissionFlag)this.m_flags; 
            }
            else if (this.IsUnrestricted()) 
            {
                isectFlags = (SecurityPermissionFlag)operand.m_flags;
            }
            else 
            {
                isectFlags = (SecurityPermissionFlag)m_flags & (SecurityPermissionFlag)operand.m_flags; 
            } 

            if (isectFlags == 0) 
                return null;
            else
                return new SecurityPermission(isectFlags);
        } 

        public override IPermission Copy() 
        { 
            if (IsUnrestricted())
                return new SecurityPermission(PermissionState.Unrestricted); 
            else
                return new SecurityPermission((SecurityPermissionFlag)m_flags);
        }
 
        public bool IsUnrestricted()
        { 
            return m_flags == SecurityPermissionFlag.AllFlags; 
        }
 
        private
        void VerifyAccess(SecurityPermissionFlag type)
        {
            if ((type & ~SecurityPermissionFlag.AllFlags) != 0) 
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
            Contract.EndContractBlock(); 
        } 

#if FEATURE_CAS_POLICY 
        //-----------------------------------------------------
        //
        // PUBLIC ENCODING METHODS
        // 
        //-----------------------------------------------------
 
        private const String _strHeaderAssertion  = "Assertion"; 
        private const String _strHeaderUnmanagedCode = "UnmanagedCode";
        private const String _strHeaderExecution = "Execution"; 
        private const String _strHeaderSkipVerification = "SkipVerification";
        private const String _strHeaderControlThread = "ControlThread";
        private const String _strHeaderControlEvidence = "ControlEvidence";
        private const String _strHeaderControlPolicy = "ControlPolicy"; 
        private const String _strHeaderSerializationFormatter = "SerializationFormatter";
        private const String _strHeaderControlDomainPolicy = "ControlDomainPolicy"; 
        private const String _strHeaderControlPrincipal = "ControlPrincipal"; 
        private const String _strHeaderControlAppDomain = "ControlAppDomain";
 
        public override SecurityElement ToXml()
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.SecurityPermission" );
            if (!IsUnrestricted()) 
            {
                esd.AddAttribute( "Flags", XMLUtil.BitFieldEnumToString( typeof( SecurityPermissionFlag ), m_flags ) ); 
            } 
            else
            { 
                esd.AddAttribute( "Unrestricted", "true" );
            }
            return esd;
        } 

        public override void FromXml(SecurityElement esd) 
        { 
            CodeAccessPermission.ValidateElement( esd, this );
            if (XMLUtil.IsUnrestricted( esd )) 
            {
                m_flags = SecurityPermissionFlag.AllFlags;
                return;
            } 

            Reset () ; 
            SetUnrestricted (false) ; 

            String flags = esd.Attribute( "Flags" ); 

            if (flags != null)
                m_flags = (SecurityPermissionFlag)Enum.Parse( typeof( SecurityPermissionFlag ), flags );
        } 
#endif // FEATURE_CAS_POLICY
 
        // 
        // Object Overrides
        // 

    #if ZERO   // Do not remove this code, usefull for debugging
        public override String ToString()
        { 
            StringBuilder sb = new StringBuilder();
            sb.Append("SecurityPermission("); 
            if (IsUnrestricted()) 
            {
                sb.Append("Unrestricted"); 
            }
            else
            {
                if (GetFlag(SecurityPermissionFlag.Assertion)) 
                    sb.Append("Assertion; ");
                if (GetFlag(SecurityPermissionFlag.UnmanagedCode)) 
                    sb.Append("UnmangedCode; "); 
                if (GetFlag(SecurityPermissionFlag.SkipVerification))
                    sb.Append("SkipVerification; "); 
                if (GetFlag(SecurityPermissionFlag.Execution))
                    sb.Append("Execution; ");
                if (GetFlag(SecurityPermissionFlag.ControlThread))
                    sb.Append("ControlThread; "); 
                if (GetFlag(SecurityPermissionFlag.ControlEvidence))
                    sb.Append("ControlEvidence; "); 
                if (GetFlag(SecurityPermissionFlag.ControlPolicy)) 
                    sb.Append("ControlPolicy; ");
                if (GetFlag(SecurityPermissionFlag.SerializationFormatter)) 
                    sb.Append("SerializationFormatter; ");
                if (GetFlag(SecurityPermissionFlag.ControlDomainPolicy))
                    sb.Append("ControlDomainPolicy; ");
                if (GetFlag(SecurityPermissionFlag.ControlPrincipal)) 
                    sb.Append("ControlPrincipal; ");
            } 
 
            sb.Append(")");
            return sb.ToString(); 
        }
    #endif

        ///  
        int IBuiltInPermission.GetTokenIndex()
        { 
            return SecurityPermission.GetTokenIndex(); 
        }
 
        internal static int GetTokenIndex()
        {
            return BuiltInPermissionIndex.SecurityPermissionIndex;
        } 

        // This can be used as a place-holder for SkipVerification permission 
        [System.Security.SecurityCritical]  // auto-generated_required 
        [SecurityPermission(SecurityAction.LinkDemand, SkipVerification = true)]
        static internal void MethodWithSkipVerificationLinkDemand() {} 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// SecurityPermission.cs
// 
// [....] 
//
 
namespace System.Security.Permissions
{
    using System;
    using System.IO; 
    using System.Security.Util;
    using System.Text; 
    using System.Threading; 
    using System.Runtime.Remoting;
    using System.Security; 
    using System.Runtime.Serialization;
    using System.Reflection;
    using System.Globalization;
    using System.Diagnostics.Contracts; 

[Serializable] 
    [Flags] 
[System.Runtime.InteropServices.ComVisible(true)]
#if !FEATURE_CAS_POLICY 
    // The csharp compiler requires these types to be public, but they are not used elsewhere.
    [Obsolete("SecurityPermissionFlag is no longer accessible to application code.")]
#endif
    public enum SecurityPermissionFlag 
    {
        NoFlags = 0x00, 
        /* The following enum value is used in the EE (ASSERT_PERMISSION in security.cpp) 
         * Should this value change, make corresponding changes there
         */ 
        Assertion = 0x01,
        UnmanagedCode = 0x02,       // Update vm\Security.h if you change this !
        SkipVerification = 0x04,    // Update vm\Security.h if you change this !
        Execution = 0x08, 
        ControlThread = 0x10,
        ControlEvidence = 0x20, 
        ControlPolicy = 0x40, 
        SerializationFormatter = 0x80,
        ControlDomainPolicy = 0x100, 
        ControlPrincipal = 0x200,
        ControlAppDomain = 0x400,
        RemotingConfiguration = 0x800,
        Infrastructure = 0x1000, 
        BindingRedirects = 0x2000,
        AllFlags = 0x3fff, 
    } 

[System.Runtime.InteropServices.ComVisible(true)] 
    [Serializable]
    sealed public class SecurityPermission
           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
    { 
        private SecurityPermissionFlag m_flags;
 
        // 
        // Public Constructors
        // 

        public SecurityPermission(PermissionState state)
        {
            if (state == PermissionState.Unrestricted) 
            {
                SetUnrestricted( true ); 
            } 
            else if (state == PermissionState.None)
            { 
                SetUnrestricted( false );
                Reset();
            }
            else 
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState")); 
            } 
        }
 

        // SecurityPermission
        //
        public SecurityPermission(SecurityPermissionFlag flag) 
        {
            VerifyAccess(flag); 
 
            SetUnrestricted(false);
            m_flags = flag; 
        }


        //------------------------------------------------------ 
        //
        // PRIVATE AND PROTECTED MODIFIERS 
        // 
        //-----------------------------------------------------
 

        private void SetUnrestricted(bool unrestricted)
        {
            if (unrestricted) 
            {
                m_flags = SecurityPermissionFlag.AllFlags; 
            } 
        }
 
        private void Reset()
        {
            m_flags = SecurityPermissionFlag.NoFlags;
        } 

 
        public SecurityPermissionFlag Flags 
        {
            set 
            {
                VerifyAccess(value);

                m_flags = value; 
            }
 
            get 
            {
                return m_flags; 
            }
        }

        // 
        // CodeAccessPermission methods
        // 
 
       /*
         * IPermission interface implementation 
         */

        public override bool IsSubsetOf(IPermission target)
        { 
            if (target == null)
            { 
                return m_flags == 0; 
            }
 
            SecurityPermission operand = target as SecurityPermission;
            if (operand != null)
            {
                return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0; 
            }
            else 
            { 
                throw new
                    ArgumentException( 
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
                                     );
            }
 
        }
 
        public override IPermission Union(IPermission target) { 
            if (target == null) return(this.Copy());
            if (!VerifyType(target)) { 
                throw new
                    ArgumentException(
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
                                     ); 
            }
            SecurityPermission sp_target = (SecurityPermission) target; 
            if (sp_target.IsUnrestricted() || IsUnrestricted()) { 
                return(new SecurityPermission(PermissionState.Unrestricted));
            } 
            SecurityPermissionFlag flag_union = (SecurityPermissionFlag)(m_flags | sp_target.m_flags);
            return(new SecurityPermission(flag_union));
        }
 
        public override IPermission Intersect(IPermission target)
        { 
            if (target == null) 
                return null;
            else if (!VerifyType(target)) 
            {
                throw new
                    ArgumentException(
                                    Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) 
                                     );
            } 
 
            SecurityPermission operand = (SecurityPermission)target;
            SecurityPermissionFlag isectFlags = SecurityPermissionFlag.NoFlags; 

            if (operand.IsUnrestricted())
            {
                if (this.IsUnrestricted()) 
                    return new SecurityPermission(PermissionState.Unrestricted);
                else 
                    isectFlags = (SecurityPermissionFlag)this.m_flags; 
            }
            else if (this.IsUnrestricted()) 
            {
                isectFlags = (SecurityPermissionFlag)operand.m_flags;
            }
            else 
            {
                isectFlags = (SecurityPermissionFlag)m_flags & (SecurityPermissionFlag)operand.m_flags; 
            } 

            if (isectFlags == 0) 
                return null;
            else
                return new SecurityPermission(isectFlags);
        } 

        public override IPermission Copy() 
        { 
            if (IsUnrestricted())
                return new SecurityPermission(PermissionState.Unrestricted); 
            else
                return new SecurityPermission((SecurityPermissionFlag)m_flags);
        }
 
        public bool IsUnrestricted()
        { 
            return m_flags == SecurityPermissionFlag.AllFlags; 
        }
 
        private
        void VerifyAccess(SecurityPermissionFlag type)
        {
            if ((type & ~SecurityPermissionFlag.AllFlags) != 0) 
                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)type));
            Contract.EndContractBlock(); 
        } 

#if FEATURE_CAS_POLICY 
        //-----------------------------------------------------
        //
        // PUBLIC ENCODING METHODS
        // 
        //-----------------------------------------------------
 
        private const String _strHeaderAssertion  = "Assertion"; 
        private const String _strHeaderUnmanagedCode = "UnmanagedCode";
        private const String _strHeaderExecution = "Execution"; 
        private const String _strHeaderSkipVerification = "SkipVerification";
        private const String _strHeaderControlThread = "ControlThread";
        private const String _strHeaderControlEvidence = "ControlEvidence";
        private const String _strHeaderControlPolicy = "ControlPolicy"; 
        private const String _strHeaderSerializationFormatter = "SerializationFormatter";
        private const String _strHeaderControlDomainPolicy = "ControlDomainPolicy"; 
        private const String _strHeaderControlPrincipal = "ControlPrincipal"; 
        private const String _strHeaderControlAppDomain = "ControlAppDomain";
 
        public override SecurityElement ToXml()
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.SecurityPermission" );
            if (!IsUnrestricted()) 
            {
                esd.AddAttribute( "Flags", XMLUtil.BitFieldEnumToString( typeof( SecurityPermissionFlag ), m_flags ) ); 
            } 
            else
            { 
                esd.AddAttribute( "Unrestricted", "true" );
            }
            return esd;
        } 

        public override void FromXml(SecurityElement esd) 
        { 
            CodeAccessPermission.ValidateElement( esd, this );
            if (XMLUtil.IsUnrestricted( esd )) 
            {
                m_flags = SecurityPermissionFlag.AllFlags;
                return;
            } 

            Reset () ; 
            SetUnrestricted (false) ; 

            String flags = esd.Attribute( "Flags" ); 

            if (flags != null)
                m_flags = (SecurityPermissionFlag)Enum.Parse( typeof( SecurityPermissionFlag ), flags );
        } 
#endif // FEATURE_CAS_POLICY
 
        // 
        // Object Overrides
        // 

    #if ZERO   // Do not remove this code, usefull for debugging
        public override String ToString()
        { 
            StringBuilder sb = new StringBuilder();
            sb.Append("SecurityPermission("); 
            if (IsUnrestricted()) 
            {
                sb.Append("Unrestricted"); 
            }
            else
            {
                if (GetFlag(SecurityPermissionFlag.Assertion)) 
                    sb.Append("Assertion; ");
                if (GetFlag(SecurityPermissionFlag.UnmanagedCode)) 
                    sb.Append("UnmangedCode; "); 
                if (GetFlag(SecurityPermissionFlag.SkipVerification))
                    sb.Append("SkipVerification; "); 
                if (GetFlag(SecurityPermissionFlag.Execution))
                    sb.Append("Execution; ");
                if (GetFlag(SecurityPermissionFlag.ControlThread))
                    sb.Append("ControlThread; "); 
                if (GetFlag(SecurityPermissionFlag.ControlEvidence))
                    sb.Append("ControlEvidence; "); 
                if (GetFlag(SecurityPermissionFlag.ControlPolicy)) 
                    sb.Append("ControlPolicy; ");
                if (GetFlag(SecurityPermissionFlag.SerializationFormatter)) 
                    sb.Append("SerializationFormatter; ");
                if (GetFlag(SecurityPermissionFlag.ControlDomainPolicy))
                    sb.Append("ControlDomainPolicy; ");
                if (GetFlag(SecurityPermissionFlag.ControlPrincipal)) 
                    sb.Append("ControlPrincipal; ");
            } 
 
            sb.Append(")");
            return sb.ToString(); 
        }
    #endif

        ///  
        int IBuiltInPermission.GetTokenIndex()
        { 
            return SecurityPermission.GetTokenIndex(); 
        }
 
        internal static int GetTokenIndex()
        {
            return BuiltInPermissionIndex.SecurityPermissionIndex;
        } 

        // This can be used as a place-holder for SkipVerification permission 
        [System.Security.SecurityCritical]  // auto-generated_required 
        [SecurityPermission(SecurityAction.LinkDemand, SkipVerification = true)]
        static internal void MethodWithSkipVerificationLinkDemand() {} 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• FtpWebRequest.cs
• XmlUnspecifiedAttribute.cs
• OdbcFactory.cs
• ProxyWebPart.cs
• SoapCodeExporter.cs
• Soap11ServerProtocol.cs
• _Win32.cs
• ForeignKeyConstraint.cs
• EqualityComparer.cs
• XmlQualifiedName.cs
• TextSyndicationContent.cs
• ReflectPropertyDescriptor.cs
• RoleGroupCollection.cs
• BitmapEffectGroup.cs
• UnSafeCharBuffer.cs
• RTLAwareMessageBox.cs
• WebScriptEndpointElement.cs
• FixedDocumentPaginator.cs
• ActivityCollectionMarkupSerializer.cs
• XmlDataSourceNodeDescriptor.cs
• CommonDialog.cs
• PropertyInformation.cs
• ReadOnlyTernaryTree.cs
• XmlTextWriter.cs
• TreeViewCancelEvent.cs
• FlowDocumentReader.cs
• HtmlUtf8RawTextWriter.cs
• HttpChannelHelper.cs
• DataMemberConverter.cs
• AccessText.cs
• TextEffect.cs
• ApplicationFileCodeDomTreeGenerator.cs
• JavaScriptString.cs
• DoubleLinkList.cs
• MembershipSection.cs
• ChangePasswordAutoFormat.cs
• ToolStripRenderEventArgs.cs
• XmlReaderSettings.cs
• FieldReference.cs
• ConstraintStruct.cs
• WindowsButton.cs
• PackagePartCollection.cs
• ProviderMetadataCachedInformation.cs
• EpmContentSerializerBase.cs
• SQLSingle.cs
• HtmlInputPassword.cs
• DataGridViewCell.cs
• InvalidateEvent.cs
• SqlNodeAnnotations.cs
• figurelengthconverter.cs
• Publisher.cs
• TextLineBreak.cs
• CompositeActivityValidator.cs
• WebRequest.cs
• Boolean.cs
• TimeoutValidationAttribute.cs
• XamlTypeMapper.cs
• Variable.cs
• BoundColumn.cs
• SafeLibraryHandle.cs
• TrustSection.cs
• StylusLogic.cs
• ListItemParagraph.cs
• WindowsFormsHost.cs
• DataGridViewAutoSizeModeEventArgs.cs
• GradientStopCollection.cs
• ButtonChrome.cs
• Rotation3DAnimationBase.cs
• GridView.cs
• Util.cs
• UrlMappingsModule.cs
• HostExecutionContextManager.cs
• MetadataItem_Static.cs
• RootDesignerSerializerAttribute.cs
• SharedUtils.cs
• EFDataModelProvider.cs
• TreeNodeStyle.cs
• WrapperSecurityCommunicationObject.cs
• sqlpipe.cs
• ImpersonateTokenRef.cs
• NativeObjectSecurity.cs
• BitmapEffect.cs
• Transform.cs
• PropertyOverridesTypeEditor.cs
• DataGridViewRowPrePaintEventArgs.cs
• QueryAsyncResult.cs
• Selection.cs
• ThicknessKeyFrameCollection.cs
• CustomAttributeFormatException.cs
• EntityParameter.cs
• MobileResource.cs
• ConfigurationStrings.cs
• MasterPageParser.cs
• DecimalFormatter.cs
• FormsAuthenticationEventArgs.cs
• CodeIdentifier.cs
• DeferredReference.cs
• RijndaelManaged.cs
• Timer.cs
• SafeNativeMethodsMilCoreApi.cs