Uranium-and-Waffles/Dec2017-Script-Dump
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scripts

Browse Source
This commit is contained in:
niko
2026-06-04 11:42:34 +02:00
parent f39ba70a9f
commit e720b98cd1
7488 changed files with 2493818 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mscorlib/System/Security/CodeAccessPermission.cs
+335
View File
@@ -0,0 +1,335 @@
using System;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security.Permissions;
namespace System.Security
{
/// <summary>Defines the underlying structure of all code access permissions.</summary>
// Token: 0x020005BC RID: 1468
[ComVisible(true)]
[MonoTODO("CAS support is experimental (and unsupported).")]
[Serializable]
public abstract class CodeAccessPermission : IPermission, ISecurityEncodable, IStackWalk
{
/// <summary>Declares that the calling code can access the resource protected by a permission demand through the code that calls this method, even if callers higher in the stack have not been granted permission to access the resource. Using <see cref="M:System.Security.CodeAccessPermission.Assert" /> can create security issues.</summary>
/// <exception cref="T:System.Security.SecurityException">The calling code does not have <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Assertion" />.-or- There is already an active <see cref="M:System.Security.CodeAccessPermission.Assert" /> for the current frame. </exception>
// Token: 0x06003595 RID: 13717 RVA: 0x000B7D10 File Offset: 0x000B5F10
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public void Assert()
{
}
// Token: 0x06003596 RID: 13718 RVA: 0x000B7D14 File Offset: 0x000B5F14
internal bool CheckAssert(CodeAccessPermission asserted)
{
return asserted != null && asserted.GetType() == base.GetType() && this.IsSubsetOf(asserted);
}
// Token: 0x06003597 RID: 13719 RVA: 0x000B7D44 File Offset: 0x000B5F44
internal bool CheckDemand(CodeAccessPermission target)
{
return target != null && target.GetType() == base.GetType() && this.IsSubsetOf(target);
}
// Token: 0x06003598 RID: 13720 RVA: 0x000B7D74 File Offset: 0x000B5F74
internal bool CheckDeny(CodeAccessPermission denied)
{
if (denied == null)
{
return true;
}
Type type = denied.GetType();
return type != base.GetType() || this.Intersect(denied) == null || denied.IsSubsetOf(PermissionBuilder.Create(type));
}
// Token: 0x06003599 RID: 13721 RVA: 0x000B7DBC File Offset: 0x000B5FBC
internal bool CheckPermitOnly(CodeAccessPermission target)
{
return target != null && target.GetType() == base.GetType() && this.IsSubsetOf(target);
}
/// <summary>When implemented by a derived class, creates and returns an identical copy of the current permission object.</summary>
/// <returns>A copy of the current permission object.</returns>
// Token: 0x0600359A RID: 13722
public abstract IPermission Copy();
/// <summary>Forces a <see cref="T:System.Security.SecurityException" /> at run time if all callers higher in the call stack have not been granted the permission specified by the current instance.</summary>
/// <exception cref="T:System.Security.SecurityException">A caller higher in the call stack does not have the permission specified by the current instance.-or- A caller higher in the call stack has called <see cref="M:System.Security.CodeAccessPermission.Deny" /> on the current permission object. </exception>
// Token: 0x0600359B RID: 13723 RVA: 0x000B7DEC File Offset: 0x000B5FEC
public void Demand()
{
}
/// <summary>Prevents callers higher in the call stack from using the code that calls this method to access the resource specified by the current instance.</summary>
/// <exception cref="T:System.Security.SecurityException">There is already an active <see cref="M:System.Security.CodeAccessPermission.Deny" /> for the current frame. </exception>
// Token: 0x0600359C RID: 13724 RVA: 0x000B7DF0 File Offset: 0x000B5FF0
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public void Deny()
{
}
/// <summary>Determines whether the specified <see cref="T:System.Security.CodeAccessPermission" /> object is equal to the current <see cref="T:System.Security.CodeAccessPermission" />.</summary>
/// <returns>true if the specified <see cref="T:System.Security.CodeAccessPermission" /> object is equal to the current <see cref="T:System.Security.CodeAccessPermission" />; otherwise, false.</returns>
/// <param name="obj">The <see cref="T:System.Security.CodeAccessPermission" /> object to compare with the current <see cref="T:System.Security.CodeAccessPermission" />. </param>
// Token: 0x0600359D RID: 13725 RVA: 0x000B7DF4 File Offset: 0x000B5FF4
[ComVisible(false)]
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj.GetType() != base.GetType())
{
return false;
}
CodeAccessPermission codeAccessPermission = obj as CodeAccessPermission;
return this.IsSubsetOf(codeAccessPermission) && codeAccessPermission.IsSubsetOf(this);
}
/// <summary>When overridden in a derived class, reconstructs a security object with a specified state from an XML encoding.</summary>
/// <param name="elem">The XML encoding to use to reconstruct the security object. </param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="elem" /> parameter is null. </exception>
/// <exception cref="T:System.ArgumentException">The <paramref name="elem" /> parameter does not contain the XML encoding for an instance of the same type as the current instance.-or- The version number of the <paramref name="elem" /> parameter is not supported. </exception>
// Token: 0x0600359E RID: 13726
public abstract void FromXml(SecurityElement elem);
/// <summary>Gets a hash code for the <see cref="T:System.Security.CodeAccessPermission" /> object that is suitable for use in hashing algorithms and data structures such as a hash table.</summary>
/// <returns>A hash code for the current <see cref="T:System.Security.CodeAccessPermission" /> object.</returns>
// Token: 0x0600359F RID: 13727 RVA: 0x000B7E3C File Offset: 0x000B603C
[ComVisible(false)]
public override int GetHashCode()
{
return base.GetHashCode();
}
/// <summary>When implemented by a derived class, creates and returns a permission that is the intersection of the current permission and the specified permission.</summary>
/// <returns>A new permission that represents the intersection of the current permission and the specified permission. This new permission is null if the intersection is empty.</returns>
/// <param name="target">A permission to intersect with the current permission. It must be of the same type as the current permission. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not an instance of the same class as the current permission. </exception>
// Token: 0x060035A0 RID: 13728
public abstract IPermission Intersect(IPermission target);
/// <summary>When implemented by a derived class, determines whether the current permission is a subset of the specified permission.</summary>
/// <returns>true if the current permission is a subset of the specified permission; otherwise, false.</returns>
/// <param name="target">A permission that is to be tested for the subset relationship. This permission must be of the same type as the current permission. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception>
// Token: 0x060035A1 RID: 13729
public abstract bool IsSubsetOf(IPermission target);
/// <summary>Creates and returns a string representation of the current permission object.</summary>
/// <returns>A string representation of the current permission object.</returns>
// Token: 0x060035A2 RID: 13730 RVA: 0x000B7E44 File Offset: 0x000B6044
public override string ToString()
{
SecurityElement securityElement = this.ToXml();
return securityElement.ToString();
}
/// <summary>When overridden in a derived class, creates an XML encoding of the security object and its current state.</summary>
/// <returns>An XML encoding of the security object, including any state information.</returns>
// Token: 0x060035A3 RID: 13731
public abstract SecurityElement ToXml();
/// <summary>When overridden in a derived class, creates a permission that is the union of the current permission and the specified permission.</summary>
/// <returns>A new permission that represents the union of the current permission and the specified permission.</returns>
/// <param name="other">A permission to combine with the current permission. It must be of the same type as the current permission. </param>
/// <exception cref="T:System.NotSupportedException">The <paramref name="other" /> parameter is not null. This method is only supported at this level when passed null. </exception>
// Token: 0x060035A4 RID: 13732 RVA: 0x000B7E60 File Offset: 0x000B6060
public virtual IPermission Union(IPermission other)
{
if (other != null)
{
throw new NotSupportedException();
}
return null;
}
/// <summary>Prevents callers higher in the call stack from using the code that calls this method to access all resources except for the resource specified by the current instance.</summary>
/// <exception cref="T:System.Security.SecurityException">There is already an active <see cref="M:System.Security.CodeAccessPermission.PermitOnly" /> for the current frame. </exception>
// Token: 0x060035A5 RID: 13733 RVA: 0x000B7E70 File Offset: 0x000B6070
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public void PermitOnly()
{
}
/// <summary>Causes all previous overrides for the current frame to be removed and no longer in effect.</summary>
/// <exception cref="T:System.ExecutionEngineException">There is no previous <see cref="M:System.Security.CodeAccessPermission.Assert" />, <see cref="M:System.Security.CodeAccessPermission.Deny" />, or <see cref="M:System.Security.CodeAccessPermission.PermitOnly" /> for the current frame. </exception>
// Token: 0x060035A6 RID: 13734 RVA: 0x000B7E74 File Offset: 0x000B6074
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public static void RevertAll()
{
}
/// <summary>Causes any previous <see cref="M:System.Security.CodeAccessPermission.Assert" /> for the current frame to be removed and no longer in effect.</summary>
/// <exception cref="T:System.ExecutionEngineException">There is no previous <see cref="M:System.Security.CodeAccessPermission.Assert" /> for the current frame. </exception>
// Token: 0x060035A7 RID: 13735 RVA: 0x000B7E78 File Offset: 0x000B6078
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public static void RevertAssert()
{
}
/// <summary>Causes any previous <see cref="M:System.Security.CodeAccessPermission.Deny" /> for the current frame to be removed and no longer in effect.</summary>
/// <exception cref="T:System.ExecutionEngineException">There is no previous <see cref="M:System.Security.CodeAccessPermission.Deny" /> for the current frame. </exception>
// Token: 0x060035A8 RID: 13736 RVA: 0x000B7E7C File Offset: 0x000B607C
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public static void RevertDeny()
{
}
/// <summary>Causes any previous <see cref="M:System.Security.CodeAccessPermission.PermitOnly" /> for the current frame to be removed and no longer in effect.</summary>
/// <exception cref="T:System.ExecutionEngineException">There is no previous <see cref="M:System.Security.CodeAccessPermission.PermitOnly" /> for the current frame. </exception>
// Token: 0x060035A9 RID: 13737 RVA: 0x000B7E80 File Offset: 0x000B6080
[MonoTODO("CAS support is experimental (and unsupported). Imperative mode is not implemented.")]
public static void RevertPermitOnly()
{
}
// Token: 0x060035AA RID: 13738 RVA: 0x000B7E84 File Offset: 0x000B6084
internal SecurityElement Element(int version)
{
SecurityElement securityElement = new SecurityElement("IPermission");
Type type = base.GetType();
securityElement.AddAttribute("class", type.FullName + ", " + type.Assembly.ToString().Replace('"', '\''));
securityElement.AddAttribute("version", version.ToString());
return securityElement;
}
// Token: 0x060035AB RID: 13739 RVA: 0x000B7EE8 File Offset: 0x000B60E8
internal static PermissionState CheckPermissionState(PermissionState state, bool allowUnrestricted)
{
if (state != PermissionState.None)
{
if (state != PermissionState.Unrestricted)
{
string text = string.Format(Locale.GetText("Invalid enum {0}"), state);
throw new ArgumentException(text, "state");
}
}
return state;
}
// Token: 0x060035AC RID: 13740 RVA: 0x000B7F38 File Offset: 0x000B6138
internal static int CheckSecurityElement(SecurityElement se, string parameterName, int minimumVersion, int maximumVersion)
{
if (se == null)
{
throw new ArgumentNullException(parameterName);
}
if (se.Tag != "IPermission")
{
string text = string.Format(Locale.GetText("Invalid tag {0}"), se.Tag);
throw new ArgumentException(text, parameterName);
}
int num = minimumVersion;
string text2 = se.Attribute("version");
if (text2 != null)
{
try
{
num = int.Parse(text2);
}
catch (Exception ex)
{
string text3 = Locale.GetText("Couldn't parse version from '{0}'.");
text3 = string.Format(text3, text2);
throw new ArgumentException(text3, parameterName, ex);
}
}
if (num < minimumVersion || num > maximumVersion)
{
string text4 = Locale.GetText("Unknown version '{0}', expected versions between ['{1}','{2}'].");
text4 = string.Format(text4, num, minimumVersion, maximumVersion);
throw new ArgumentException(text4, parameterName);
}
return num;
}
// Token: 0x060035AD RID: 13741 RVA: 0x000B8028 File Offset: 0x000B6228
internal static bool IsUnrestricted(SecurityElement se)
{
string text = se.Attribute("Unrestricted");
return text != null && string.Compare(text, bool.TrueString, true, CultureInfo.InvariantCulture) == 0;
}
// Token: 0x060035AE RID: 13742 RVA: 0x000B8060 File Offset: 0x000B6260
internal bool ProcessFrame(SecurityFrame frame)
{
if (frame.PermitOnly != null)
{
bool flag = frame.PermitOnly.IsUnrestricted();
if (!flag)
{
foreach (object obj in frame.PermitOnly)
{
IPermission permission = (IPermission)obj;
if (this.CheckPermitOnly(permission as CodeAccessPermission))
{
flag = true;
break;
}
}
}
if (!flag)
{
CodeAccessPermission.ThrowSecurityException(this, "PermitOnly", frame, SecurityAction.Demand, null);
}
}
if (frame.Deny != null)
{
if (frame.Deny.IsUnrestricted())
{
CodeAccessPermission.ThrowSecurityException(this, "Deny", frame, SecurityAction.Demand, null);
}
foreach (object obj2 in frame.Deny)
{
IPermission permission2 = (IPermission)obj2;
if (!this.CheckDeny(permission2 as CodeAccessPermission))
{
CodeAccessPermission.ThrowSecurityException(this, "Deny", frame, SecurityAction.Demand, permission2);
}
}
}
if (frame.Assert != null)
{
if (frame.Assert.IsUnrestricted())
{
return true;
}
foreach (object obj3 in frame.Assert)
{
IPermission permission3 = (IPermission)obj3;
if (this.CheckAssert(permission3 as CodeAccessPermission))
{
return true;
}
}
return false;
}
return false;
}
// Token: 0x060035AF RID: 13743 RVA: 0x000B8260 File Offset: 0x000B6460
internal static void ThrowInvalidPermission(IPermission target, Type expected)
{
string text = Locale.GetText("Invalid permission type '{0}', expected type '{1}'.");
text = string.Format(text, target.GetType(), expected);
throw new ArgumentException(text, "target");
}
// Token: 0x060035B0 RID: 13744 RVA: 0x000B8294 File Offset: 0x000B6494
internal static void ThrowExecutionEngineException(SecurityAction stackmod)
{
string text = Locale.GetText("No {0} modifier is present on the current stack frame.");
text = text + Environment.NewLine + "Currently only declarative stack modifiers are supported.";
throw new ExecutionEngineException(string.Format(text, stackmod));
}
// Token: 0x060035B1 RID: 13745 RVA: 0x000B82D0 File Offset: 0x000B64D0
internal static void ThrowSecurityException(object demanded, string message, SecurityFrame frame, SecurityAction action, IPermission failed)
{
throw new SecurityException(message);
}
}
}