public RoleUserController(IRoleUser repoRoleUser , IRole repoRole, IPermission repoPer) { dalRoleUser = repoRoleUser; dalRole = repoRole; dalPermission = repoPer; }
// Determine if a specific permission has been granted. public static bool IsGranted(IPermission perm) { // Bail out if the requested permission is null. if(perm == null) { return true; } // Get the current permission state. ClrPermissions current = ClrSecurity.GetPermissionsFrom(1); if(current == null) { // Null is equivalent to "unrestricted". return true; } // Build a permission set with just this permission. PermissionSet set = new PermissionSet(PermissionState.None); set.AddPermission(perm); // If "PermitOnly" is set, then only check that set. if(current.permitOnly != null) { return set.IsSubsetOf(current.permitOnly); } // The permission must be granted, but not denied. if(!set.IsSubsetOf(current.granted) || set.IsSubsetOf(current.denied)) { return false; } return true; }
public override bool IsSubsetOf(IPermission target) { bool flag; if (target == null) { return !this.unrestricted; } try { DistributedTransactionPermission permission = (DistributedTransactionPermission) target; if (!this.unrestricted) { return true; } if (permission.unrestricted) { return true; } flag = false; } catch (InvalidCastException) { throw new ArgumentException(System.Transactions.SR.GetString("ArgumentWrongType"), "target"); } return flag; }
public override IPermission Intersect(IPermission target) { if (target == null) { return null; } if (!base.VerifyType(target)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } SecurityPermission permission = (SecurityPermission) target; SecurityPermissionFlag noFlags = SecurityPermissionFlag.NoFlags; if (permission.IsUnrestricted()) { if (this.IsUnrestricted()) { return new SecurityPermission(PermissionState.Unrestricted); } noFlags = this.m_flags; } else if (this.IsUnrestricted()) { noFlags = permission.m_flags; } else { noFlags = this.m_flags & permission.m_flags; } if (noFlags == SecurityPermissionFlag.NoFlags) { return null; } return new SecurityPermission(noFlags); }
internal static SecurityElement CreatePermissionElement(IPermission perm, string permname) { SecurityElement element = new SecurityElement("IPermission"); XMLUtil.AddClassAttribute(element, perm.GetType(), permname); element.AddAttribute("version", "1"); return element; }
public override bool IsSubsetOf(IPermission target) { bool flag; if (target == null) { return (this.access == FileDialogPermissionAccess.None); } try { FileDialogPermission permission = (FileDialogPermission) target; if (permission.IsUnrestricted()) { return true; } if (this.IsUnrestricted()) { return false; } int num = ((int) this.access) & 1; int num2 = ((int) this.access) & 2; int num3 = ((int) permission.Access) & 1; int num4 = ((int) permission.Access) & 2; flag = (num <= num3) && (num2 <= num4); } catch (InvalidCastException) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } return flag; }
public TestBase() { var builder = new ContainerBuilder(); builder.RegisterType<DatabaseFactory>().As<IDatabaseFactory>().InstancePerLifetimeScope(); builder.RegisterType<UnityOfWork>().As<IUnitOfWork>(); builder.RegisterType<ContactRepostory>().AsImplementedInterfaces(); builder.RegisterType<ContactServices>().AsImplementedInterfaces(); builder.RegisterType<ProductRepository>().AsImplementedInterfaces(); builder.RegisterType<LodgingRepository>().AsImplementedInterfaces(); builder.RegisterType<ResortRepository>().AsImplementedInterfaces(); builder.RegisterType<ProductService>().AsImplementedInterfaces(); builder.RegisterType<LodgingService>().AsImplementedInterfaces(); builder.RegisterType<ResortService>().AsImplementedInterfaces(); #region 权限 builder.RegisterType<PermissionModuleRepository>().AsImplementedInterfaces(); builder.RegisterType<PermissionRoleRepository>().AsImplementedInterfaces(); builder.RegisterType<PermissionReRoleModuleRepostory>().AsImplementedInterfaces(); builder.RegisterType<PermissionSvc>().AsImplementedInterfaces(); #endregion container= builder.Build(); this.unitOfWork = container.Resolve<IUnitOfWork>(); this.contact=container.Resolve<IContact>(); this.productsvc=container.Resolve<IProduct>(); this.resortSvc = container.Resolve<IResort>(); this.lodgingsvc = container.Resolve<ILodging>(); this.permissionSvc = container.Resolve<IPermission>(); // StartUp(); }
public override IPermission Intersect(IPermission target) { if (target == null) { return null; } if (!base.VerifyType(target)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } IsolatedStorageFilePermission permission = (IsolatedStorageFilePermission) target; if (permission.IsUnrestricted()) { return this.Copy(); } if (base.IsUnrestricted()) { return target.Copy(); } IsolatedStorageFilePermission permission2 = new IsolatedStorageFilePermission(PermissionState.None) { m_userQuota = IsolatedStoragePermission.min(base.m_userQuota, permission.m_userQuota), m_machineQuota = IsolatedStoragePermission.min(base.m_machineQuota, permission.m_machineQuota), m_expirationDays = IsolatedStoragePermission.min(base.m_expirationDays, permission.m_expirationDays), m_permanentData = base.m_permanentData && permission.m_permanentData, m_allowed = (IsolatedStorageContainment) ((int) IsolatedStoragePermission.min((long) base.m_allowed, (long) permission.m_allowed)) }; if ((((permission2.m_userQuota == 0L) && (permission2.m_machineQuota == 0L)) && ((permission2.m_expirationDays == 0L) && !permission2.m_permanentData)) && (permission2.m_allowed == IsolatedStorageContainment.None)) { return null; } return permission2; }
//------------------------------------------------------ // // IPERMISSION IMPLEMENTATION // //------------------------------------------------------ public override IPermission Union(IPermission target) { if (target == null) { return this.Copy(); } else if (!VerifyType(target)) { throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) ); } IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target; if (this.IsUnrestricted() || operand.IsUnrestricted()) { return new IsolatedStorageFilePermission( PermissionState.Unrestricted ); } else { IsolatedStorageFilePermission union; union = new IsolatedStorageFilePermission( PermissionState.None ); union.m_userQuota = max(m_userQuota,operand.m_userQuota); union.m_machineQuota = max(m_machineQuota,operand.m_machineQuota); union.m_expirationDays = max(m_expirationDays,operand.m_expirationDays); union.m_permanentData = m_permanentData || operand.m_permanentData; union.m_allowed = (IsolatedStorageContainment)max((long)m_allowed,(long)operand.m_allowed); return union; } }
public override bool IsSubsetOf(IPermission target) { if (target == null) { return ((m_userQuota == 0) && (m_machineQuota == 0) && (m_expirationDays == 0) && (m_permanentData == false) && (m_allowed == IsolatedStorageContainment.None)); } try { IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target; if (operand.IsUnrestricted()) return true; return ((operand.m_userQuota >= m_userQuota) && (operand.m_machineQuota >= m_machineQuota) && (operand.m_expirationDays >= m_expirationDays) && (operand.m_permanentData || !m_permanentData) && (operand.m_allowed >= m_allowed)); } catch (InvalidCastException) { throw new ArgumentException( Environment.GetResourceString("Argument_WrongType", this.GetType().FullName) ); } }
public override IPermission Intersect(IPermission target) { //If nothing was passed, return null. if (null == target) { return null; } try { //Create a new instance of RobocodeInternalPermission from the passed object. var PassedPermission = (RobocodeInternalPermission) target; //If one class has an unrestricted value of false, then the //intersection will have an unrestricted value of false. //Return the passed class with the unrestricted value of false. if (!PassedPermission.unrestricted) { return target; } //Return a copy of the current class if the passed one has //an unrestricted value of true. return Copy(); } //Catch an InvalidCastException. //Throw ArgumentException to notify the user. catch (InvalidCastException) { throw new ArgumentException("Argument_WrongType", GetType().FullName); } }
public override IPermission Intersect(IPermission target) { if (target == null) return null; return this.Copy(); }
[System.Security.SecurityCritical] // auto-generated private static bool FrameDescHelper(FrameSecurityDescriptor secDesc, IPermission demandIn, PermissionToken permToken, RuntimeMethodHandleInternal rmh) { return secDesc.CheckDemand((CodeAccessPermission) demandIn, permToken, rmh); }
public override IPermission Intersect (IPermission target) { GacIdentityPermission gip = Cast (target); if (gip == null) return null; return Copy (); }
public override bool IsSubsetOf (IPermission target) { ZoneIdentityPermission zip = Cast (target); if (zip == null) return (zone == SecurityZone.NoZone); return ((zone == SecurityZone.NoZone) || (zone == zip.zone)); }
public void Add(IPermission permission) { if (Permissions == null) { Permissions = new HashSet<IPermission>(); } Permissions.Add(permission); }
public override bool IsSubsetOf (IPermission target) { DnsPermission dp = Cast (target); if (dp == null) return IsEmpty (); return (dp.IsUnrestricted () || (m_noRestriction == dp.m_noRestriction)); }
public ModuleController(IModule repoModule, IModuleFunction repoFun, IPermission repoAction) { dalModule = repoModule; dalFunction = repoFun; //dalAction = repoAction; dalPermission = repoAction; }
public override bool IsSubsetOf(IPermission target) { if (target == null) return false; if (!(target is GacIdentityPermission)) throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)); return true; }
public override IPermission Intersect(IPermission target) { if (target == null) return null; if (!(target is GacIdentityPermission)) throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)); return this.Copy(); }
// IBuiltInPermission is internal but we can test it's values // using reflection. private int GetTokenIndex (IPermission p) { Type t = p.GetType (); int result = (int) t.InvokeMember ("System.Security.Permissions.IBuiltInPermission.GetTokenIndex", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, p, null); return result; }
static bool IsNotGranted(IPermission permission) { var securityComplex = ((SecurityBase)SecuritySystem.Instance); bool isGrantedForNonExistentPermission = securityComplex.IsGrantedForNonExistentPermission; securityComplex.IsGrantedForNonExistentPermission = true; bool granted = SecuritySystem.IsGranted(permission); securityComplex.IsGrantedForNonExistentPermission = isGrantedForNonExistentPermission; return granted; }
public IPermission Intersect(IPermission other) { IList<String> permissions = GetOther(other).Permissions.Intersect(Permissions).ToList(); return 0 != permissions.Count ? new PolicyPermission(permissions) : null; }
public void AddObjectPermission(IPermission permission) { if (_objectPermissions == null) { _objectPermissions = new HashSet<IPermission>(); } _objectPermissions.Add(permission); }
public override IPermission Union(IPermission target) { if ((target != null) && !(target is GacIdentityPermission)) { throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[] { base.GetType().FullName })); } return this.Copy(); }
public override bool IsSubsetOf(IPermission target) { var isSubsetOf = base.IsSubsetOf(target); if (isSubsetOf) { var stateMachineTransitionPermission = ((StateMachineTransitionPermission)target); return stateMachineTransitionPermission.StateCaption == StateCaption && stateMachineTransitionPermission.StateMachineName == StateMachineName; } return false; }
public override IPermission Intersect (IPermission target) { DnsPermission dp = Cast (target); if (dp == null) return null; if (IsUnrestricted () && dp.IsUnrestricted ()) return new DnsPermission (PermissionState.Unrestricted); return null; }
private static XamlLoadPermission CastPermission(IPermission other, string argName) { XamlLoadPermission permission = other as XamlLoadPermission; if (permission == null) { throw new ArgumentException(System.Xaml.SR.Get("ExpectedLoadPermission"), argName); } return permission; }
public Boolean IsSubsetOf(IPermission other) { PolicyPermission policyPermission = GetOther(other); foreach (String permission in Permissions) if (false == policyPermission.Permissions.Contains(permission)) return false; return true; }
// // Public APIs // public static bool IsGranted( IPermission perm ) { if (perm == null) return true; PermissionSet granted, denied; StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; _GetGrantedPermissions( out granted, out denied, ref stackMark ); return granted.Contains( perm ) && (denied == null || !denied.Contains( perm )); }
public void KeyContainer() { IPermission p = (IPermission) new KeyContainerPermission(PermissionState.None); Assert.AreEqual(16, GetTokenIndex(p)); }
public SecurityException(string message, object deny, object permitOnly, MethodInfo method, object demanded, IPermission permThatFailed) : base(message) { PermissionSet.s_fullTrust.Assert(); base.SetErrorCode(-2146233078); this.Action = SecurityAction.Demand; if (permThatFailed != null) { this.m_typeOfPermissionThatFailed = permThatFailed.GetType(); } this.FirstPermissionThatFailed = permThatFailed; this.Demanded = demanded; this.m_granted = ""; this.m_refused = ""; this.DenySetInstance = deny; this.PermitOnlySetInstance = permitOnly; this.m_assemblyName = null; this.Method = method; this.m_zone = SecurityZone.NoZone; this.m_url = ""; this.m_debugString = this.ToString(true, false); }
public SecurityException(string message, AssemblyName assemblyName, PermissionSet grant, PermissionSet refused, MethodInfo method, SecurityAction action, object demanded, IPermission permThatFailed, Evidence evidence) : base(message) { PermissionSet.s_fullTrust.Assert(); base.SetErrorCode(-2146233078); this.Action = action; if (permThatFailed != null) { this.m_typeOfPermissionThatFailed = permThatFailed.GetType(); } this.FirstPermissionThatFailed = permThatFailed; this.Demanded = demanded; this.m_granted = (grant == null) ? "" : grant.ToXml().ToString(); this.m_refused = (refused == null) ? "" : refused.ToXml().ToString(); this.m_denied = ""; this.m_permitOnly = ""; this.m_assemblyName = assemblyName; this.Method = method; this.m_url = ""; this.m_zone = SecurityZone.NoZone; if (evidence != null) { System.Security.Policy.Url hostEvidence = evidence.GetHostEvidence <System.Security.Policy.Url>(); if (hostEvidence != null) { this.m_url = hostEvidence.GetURLString().ToString(); } System.Security.Policy.Zone zone = evidence.GetHostEvidence <System.Security.Policy.Zone>(); if (zone != null) { this.m_zone = zone.SecurityZone; } } this.m_debugString = this.ToString(true, false); }
internal static Exception MakeSecurityException(AssemblyName asmName, Evidence asmEvidence, PermissionSet granted, PermissionSet refused, RuntimeMethodHandleInternal rmh, SecurityAction action, object demand, IPermission permThatFailed) { HostProtectionPermission permission = permThatFailed as HostProtectionPermission; if (permission != null) { return(new HostProtectionException(GetResString("HostProtection_HostProtection"), HostProtectionPermission.protectedResources, permission.Resources)); } string message = ""; MethodInfo method = null; try { if (((granted == null) && (refused == null)) && (demand == null)) { message = GetResString("Security_NoAPTCA"); } else if ((demand != null) && (demand is IPermission)) { message = string.Format(CultureInfo.InvariantCulture, GetResString("Security_Generic"), new object[] { demand.GetType().AssemblyQualifiedName }); } else if (permThatFailed != null) { message = string.Format(CultureInfo.InvariantCulture, GetResString("Security_Generic"), new object[] { permThatFailed.GetType().AssemblyQualifiedName }); } else { message = GetResString("Security_GenericNoType"); } method = SecurityRuntime.GetMethodInfo(rmh); } catch (Exception exception) { if (exception is ThreadAbortException) { throw; } } return(new SecurityException(message, asmName, granted, refused, method, action, demand, permThatFailed, asmEvidence)); }
/// <summary>Adds a specified permission to the <see cref="T:System.Security.PermissionSet" />.</summary> /// <returns>The union of the permission added and any permission of the same type that already exists in the <see cref="T:System.Security.PermissionSet" />.</returns> /// <param name="perm">The permission to add. </param> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" /> /// </PermissionSet> public IPermission AddPermission(IPermission perm) { return(perm); }
public void Environment() { IPermission p = (IPermission) new EnvironmentPermission(PermissionState.None); Assert.AreEqual(0, GetTokenIndex(p)); }
public override IPermission Union(IPermission target) { return(default(IPermission)); }
public override bool IsSubsetOf(IPermission target) { return(false); }
public override IPermission Union(IPermission target) { return(null); }
public override IPermission Intersect(IPermission target) { return(default(IPermission)); }
public override bool IsSubsetOf(IPermission target) => false;
} //Copy() public override IPermission Intersect(IPermission target) { if (target == null) return null; if (typeof(myperm) != target.GetType()) return null; return new myperm(); } //Intersect()
public void Principal() { IPermission p = (IPermission) new PrincipalPermission(PermissionState.None); Assert.AreEqual(8, GetTokenIndex(p)); }
public void GacIdentity() { IPermission p = (IPermission) new GacIdentityPermission(PermissionState.None); Assert.AreEqual(15, GetTokenIndex(p)); }
public override IPermission Intersect(IPermission target) { return(null); }
} //Intersect() public override IPermission Union(IPermission target) { if (target == null) return new myperm(); if (typeof(myperm) != target.GetType()) return null; return new myperm(); } //Union()
} //FromXml() public override bool IsSubsetOf(IPermission target) { if (target == null) return false; if (typeof(myperm) != target.GetType()) return false; return true; } //IsSubsetOf()
internal PermissionToken GetToken(Type cls, IPermission perm) { Contract.Assert(cls != null, "Must pass in valid type"); IntPtr typePtr = cls.TypeHandle.Value; object tok = m_handleTable[typePtr]; if (tok == null) { String typeStr = cls.AssemblyQualifiedName; tok = m_tokenTable != null ? m_tokenTable[typeStr] : null; // Assumes asynchronous lookups are safe if (tok == null) { lock (this) { if (m_tokenTable != null) { tok = m_tokenTable[typeStr]; // Make sure it wasn't just added } else { m_tokenTable = new Hashtable(m_size, 1.0f, new PermissionTokenKeyComparer()); } if (tok == null) { if (perm != null) { tok = new PermissionToken(m_index++, PermissionTokenType.IUnrestricted, typeStr); } else { if (cls.GetInterface(s_unrestrictedPermissionInferfaceName) != null) { tok = new PermissionToken(m_index++, PermissionTokenType.IUnrestricted, typeStr); } else { tok = new PermissionToken(m_index++, PermissionTokenType.Normal, typeStr); } } m_tokenTable.Add(typeStr, tok); m_indexTable.Add(m_index - 1, tok); PermissionToken.s_tokenSet.SetItem(((PermissionToken)tok).m_index, tok); } if (!m_handleTable.Contains(typePtr)) { m_handleTable.Add(typePtr, tok); } } } else { lock (this) { if (!m_handleTable.Contains(typePtr)) { m_handleTable.Add(typePtr, tok); } } } } if ((((PermissionToken)tok).m_type & PermissionTokenType.DontKnow) != 0) { if (perm != null) { Contract.Assert(!(perm is IBuiltInPermission), "This should not be called for built-ins"); ((PermissionToken)tok).m_type = PermissionTokenType.IUnrestricted; } else { Contract.Assert(cls.GetInterface("System.Security.Permissions.IBuiltInPermission") == null, "This shoudl not be called for built-ins"); if (cls.GetInterface(s_unrestrictedPermissionInferfaceName) != null) { ((PermissionToken)tok).m_type = PermissionTokenType.IUnrestricted; } else { ((PermissionToken)tok).m_type = PermissionTokenType.Normal; } } } return((PermissionToken)tok); }
public void UI() { IPermission p = (IPermission) new UIPermission(PermissionState.None); Assert.AreEqual(7, GetTokenIndex(p)); }