static bool TryProcessPermissionSetAttribute (SecurityDeclaration declaration, out PermissionSet set)
{
set = null;
if (!declaration.HasSecurityAttributes && declaration.SecurityAttributes.Count != 1)
return false;
var security_attribute = declaration.SecurityAttributes [0];
var attribute_type = security_attribute.AttributeType;
if (attribute_type.Name != "PermissionSetAttribute" || attribute_type.Namespace != "System.Security.Permissions")
return false;
var attribute = new SSP.PermissionSetAttribute ((SSP.SecurityAction) declaration.Action);
var named_argument = security_attribute.Properties [0];
string value = (string) named_argument.Argument.Value;
switch (named_argument.Name) {
case "XML":
attribute.XML = value;
break;
case "Name":
attribute.Name = value;
break;
default:
throw new NotImplementedException (named_argument.Name);
}
set = attribute.CreatePermissionSet ();
return true;
}
public static void CopySecurityAttributes(SecurityDeclaration source, SecurityDeclaration target, ReferenceResolver resolver)
{
if (!source.HasSecurityAttributes)
return;
foreach (var attribute in source.SecurityAttributes)
target.InjectSecurityAttribute(attribute, resolver);
}
static PermissionSet CreatePermissionSet (SecurityDeclaration declaration)
{
var set = new PermissionSet (SSP.PermissionState.None);
foreach (var attribute in declaration.SecurityAttributes) {
var permission = CreatePermission (declaration, attribute);
set.AddPermission (permission);
}
return set;
}
public SecurityDeclaration FromByteArray (SecurityAction action, byte [] declaration, bool resolve)
{
SecurityDeclaration dec = new SecurityDeclaration (action, this);
#if !CF_1_0 && !CF_2_0
dec.PermissionSet = new PermissionSet (SSP.PermissionState.None);
if (IsEmptyDeclaration (declaration))
return dec;
if (declaration[0] == 0x2e) {
// new binary format introduced in 2.0
int pos = 1;
int start;
int numattr = Utilities.ReadCompressedInteger (declaration, pos, out start);
if (numattr == 0)
return dec;
BinaryReader br = new BinaryReader (new MemoryStream (declaration));
for (int i = 0; i < numattr; i++) {
pos = start;
SSP.SecurityAttribute sa = CreateSecurityAttribute (action, br, declaration, pos, out start, resolve);
if (sa == null) {
dec.Resolved = false;
dec.Blob = declaration;
return dec;
}
try {
IPermission p = sa.CreatePermission ();
dec.PermissionSet.AddPermission (p);
} catch {
dec.Resolved = false;
dec.Blob = declaration;
return dec;
}
}
dec.Resolved = true;
} else {
Parser.LoadXml (Encoding.Unicode.GetString (declaration));
try {
dec.PermissionSet.FromXml (Parser.ToXml ());
dec.PermissionSet.ToXml ();
dec.Resolved = true;
} catch {
dec.Resolved = false;
dec.Blob = declaration;
}
}
#endif
return dec;
}
static IPermission CreatePermission (SecurityDeclaration declaration, SecurityAttribute attribute)
{
var attribute_type = Type.GetType (attribute.AttributeType.FullName);
if (attribute_type == null)
throw new ArgumentException ();
var security_attribute = CreateSecurityAttribute (attribute_type, declaration);
if (security_attribute == null)
throw new InvalidOperationException ();
CompleteSecurityAttribute (security_attribute, attribute);
return security_attribute.CreatePermission ();
}
internal static SecurityDeclaration Clone (SecurityDeclaration sec)
{
SecurityDeclaration sd = new SecurityDeclaration (sec.Action);
if (!sec.IsReadable) {
sd.IsReadable = false;
sd.Blob = sec.Blob;
return sd;
}
#if !CF_1_0 && !CF_2_0
sd.PermissionSet = sec.PermissionSet.Copy ();
#endif
return sd;
}
static bool TryProcessPermissionSetAttribute (SecurityDeclaration declaration, out PermissionSet set)
{
set = null;
if (!declaration.HasSecurityAttributes)
return false;
var attributes = declaration.SecurityAttributes;
if (attributes.Count != 1)
return false;
var security_attribute = attributes [0];
var attribute_type = security_attribute.AttributeType;
if (attribute_type.Name != "PermissionSetAttribute" || attribute_type.Namespace != "System.Security.Permissions")
return false;
var attribute = new SSP.PermissionSetAttribute ((SSP.SecurityAction) declaration.Action);
foreach (var named_argument in security_attribute.Properties) {
object value = named_argument.Argument.Value;
switch (named_argument.Name) {
case "Unrestricted":
attribute.Unrestricted = (bool) value;
break;
case "UnicodeEncoded":
attribute.UnicodeEncoded = (bool) value;
break;
case "XML":
attribute.XML = (string) value;
break;
case "Name":
attribute.Name = (string) value;
break;
case "File":
attribute.File = (string) value;
break;
case "Hex":
attribute.Hex = (string) value;
break;
default:
throw new NotImplementedException (named_argument.Name);
}
}
set = attribute.CreatePermissionSet ();
return true;
}
public void Add (SecurityDeclaration value)
{
if (value == null)
throw new ArgumentNullException ("value");
// Each action can only be added once so...
SecurityDeclaration current = (SecurityDeclaration) m_items[value.Action];
if (current != null) {
// ... further additions are transformed into unions
#if !CF_1_0 && !CF_2_0
current.PermissionSet = current.PermissionSet.Union (value.PermissionSet);
#endif
} else {
m_items.Add (value.Action, value);
SetHasSecurity (true);
}
}
public static bool IsXmlPermissionSet(SecurityDeclaration xmlDeclaration)
{
if (!xmlDeclaration.HasSecurityAttributes || xmlDeclaration.SecurityAttributes.Count == 0)
// nothing to convert
return false;
if (xmlDeclaration.SecurityAttributes.Count > 1)
return false;
SecurityAttribute sa = xmlDeclaration.SecurityAttributes[0];
if (sa.HasFields)
return false;
if (!sa.HasProperties || sa.Properties.Count > 1)
return false;
CustomAttributeNamedArgument arg = sa.Properties[0];
if (arg.Name != "XML" || arg.Argument.Type.FullName != "System.String")
return false;
return true;
}
public static SecurityDeclaration Permission2XmlSet(SecurityDeclaration declaration, ModuleDefinition targetModule)
{
if (!declaration.HasSecurityAttributes || declaration.SecurityAttributes.Count == 0)
// nothing to convert
return declaration;
if (declaration.SecurityAttributes.Count > 1)
throw new Exception("Cannot convert SecurityDeclaration with more than one attribute");
SecurityAttribute sa = declaration.SecurityAttributes[0];
if (sa.HasFields)
throw new NotSupportedException("Cannot convert SecurityDeclaration with fields");
TypeReference attrType = sa.AttributeType;
AssemblyNameReference attrAsm = (AssemblyNameReference)attrType.Scope;
string className = attrType.FullName + ", " + attrAsm.FullName;
XmlDocument xmlDoc = new XmlDocument();
XmlElement permissionSet = xmlDoc.CreateElement("PermissionSet");
permissionSet.SetAttribute("class", "System.Security.PermissionSet");
permissionSet.SetAttribute("version", "1");
XmlElement iPermission = xmlDoc.CreateElement("IPermission");
iPermission.SetAttribute("class", className);
iPermission.SetAttribute("version", "1");
foreach (var arg in sa.Properties)
{
iPermission.SetAttribute(arg.Name, arg.Argument.Value.ToString());
}
permissionSet.AppendChild(iPermission);
xmlDoc.AppendChild(permissionSet);
string xmlDocString = xmlDoc.InnerXml;
SecurityDeclaration xmlDeclaration = new SecurityDeclaration(declaration.Action);
SecurityAttribute attribute = new SecurityAttribute(GetTypeRef("System.Security.Permissions", "PermissionSetAttribute", "mscorlib", targetModule));
attribute.Properties.Add(new CustomAttributeNamedArgument("XML",
new CustomAttributeArgument(targetModule.TypeSystem.String, xmlDoc.InnerXml)));
xmlDeclaration.SecurityAttributes.Add(attribute);
return xmlDeclaration;
}
static bool TryProcessPermissionSetAttribute (SecurityDeclaration declaration, out PermissionSet set)
{
set = null;
if (!declaration.HasSecurityAttributes && declaration.SecurityAttributes.Count != 1)
return false;
var security_attribute = declaration.SecurityAttributes [0];
var attribute_type = security_attribute.AttributeType;
if (attribute_type.Name != "PermissionSetAttribute" || attribute_type.Namespace != "System.Security.Permissions")
return false;
var named_argument = security_attribute.Properties [0];
if (named_argument.Name != "XML")
throw new NotSupportedException ();
var attribute = new SSP.PermissionSetAttribute ((SSP.SecurityAction) declaration.Action);
attribute.XML = (string) named_argument.Argument.Value;
set = attribute.CreatePermissionSet ();
return true;
}
public virtual void VisitSecurityDeclaration(SecurityDeclaration secDecl)
{
}
static SSP.SecurityAttribute CreateSecurityAttribute (Type attribute_type, SecurityDeclaration declaration)
{
SSP.SecurityAttribute security_attribute;
try {
security_attribute = (SSP.SecurityAttribute) Activator.CreateInstance (
attribute_type, new object [] { (SSP.SecurityAction) declaration.Action });
} catch (MissingMethodException) {
security_attribute = (SSP.SecurityAttribute) Activator.CreateInstance (attribute_type, new object [0]);
}
return security_attribute;
}
static IPermission CreatePermission (SecurityDeclaration declaration, SecurityAttribute attribute)
{
TypeReference atype = attribute.AttributeType;
string name = atype.FullName;
// most of the permissions resides inside mscorlib.dll
Type attribute_type = Type.GetType (name);
if (attribute_type == null) {
// but not all of them, so we need to try harder :-)
TypeDefinition rtype = atype.Resolve ();
AssemblyDefinition ad = rtype == null ? atype.Module.Assembly : rtype.Module.Assembly;
attribute_type = Type.GetType (name + ", " + ad.FullName);
}
if (attribute_type == null)
throw new ArgumentException ("attribute");
var security_attribute = CreateSecurityAttribute (attribute_type, declaration);
if (security_attribute == null)
throw new InvalidOperationException ();
CompleteSecurityAttribute (security_attribute, attribute);
return security_attribute.CreatePermission ();
}
public static SecurityDeclaration Xml2PermissionSet(SecurityDeclaration xmlDeclaration, ModuleDefinition targetModule)
{
if (!xmlDeclaration.HasSecurityAttributes || xmlDeclaration.SecurityAttributes.Count == 0)
// nothing to convert
return null;
if (xmlDeclaration.SecurityAttributes.Count > 1)
throw new Exception("Cannot convert SecurityDeclaration with more than one attribute");
SecurityAttribute sa = xmlDeclaration.SecurityAttributes[0];
if (sa.HasFields)
throw new NotSupportedException("Cannot convert SecurityDeclaration with fields");
if (!sa.HasProperties || sa.Properties.Count > 1)
throw new NotSupportedException("Invalid XML SecurityDeclaration (only 1 property supported)");
CustomAttributeNamedArgument arg = sa.Properties[0];
if (arg.Name != "XML" || arg.Argument.Type.FullName != "System.String")
throw new ArgumentException("Property \"XML\" expected");
if (string.IsNullOrEmpty(arg.Argument.Value as string))
return null;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml((string)arg.Argument.Value);
XmlNode permissionSet = xmlDoc.SelectSingleNode("/PermissionSet");
if (permissionSet == null)
return null;
XmlNode permissionSetClass = permissionSet.SelectSingleNode("@class"); // check version?
if (permissionSetClass == null)
return null;
if (permissionSetClass.Value != "System.Security.PermissionSet")
return null;
XmlNode iPermission = permissionSet.SelectSingleNode("IPermission");
if (iPermission == null)
return null;
XmlNode iPermissionClass = iPermission.SelectSingleNode("@class"); // check version?
if (iPermissionClass == null)
return null;
// Create Namespace & Name from FullName, AssemblyName can be ignored since we look it up.
string[] valueParts = iPermissionClass.Value.Split(',');
Collection<string> classNamespace = new Collection<string>(valueParts[0].Split('.'));
string assemblyName = valueParts[1].Trim();
string className = classNamespace[classNamespace.Count - 1];
classNamespace.RemoveAt(classNamespace.Count - 1);
SecurityAttribute attribute = new SecurityAttribute(GetTypeRef(string.Join(".", classNamespace.ToArray()), className, assemblyName, targetModule));
foreach (XmlAttribute xmlAttr in iPermission.Attributes)
{
if ((xmlAttr.Name != "class") && (xmlAttr.Name != "version"))
{
attribute.Properties.Add(new CustomAttributeNamedArgument(xmlAttr.Name,
new CustomAttributeArgument(targetModule.TypeSystem.String, xmlAttr.Value)));
}
}
SecurityDeclaration newSd = new SecurityDeclaration(xmlDeclaration.Action);
newSd.SecurityAttributes.Add(attribute);
return newSd;
}
private IEnumerable<ICustomAttribute> GetSecurityDeclaration(SecurityDeclaration securityDeclaration)
{
List<ICustomAttribute> attributes = new List<ICustomAttribute>();
if (securityDeclaration.HasSecurityAttributes)
{
foreach (SecurityAttribute attribute in securityDeclaration.SecurityAttributes)
{
attributes.Add(attribute);
securityAttributeToDeclaration.Add(attribute, securityDeclaration);
}
}
return attributes;
}
public virtual void VisitSecurityDeclaration(SecurityDeclaration secDecl)
{
}
private void WriteSecurityDeclaration(SecurityDeclaration declaration)
{
WriteDot();
WriteKeyword("permissionset");
WriteSpace();
string actionKeyword = GetActionKeyword(declaration.Action);
WriteKeyword(actionKeyword);
WriteSpace();
Write("=");
WriteLine();
WriteOpenBreckets();
WriteLine();
Indent();
if (declaration.HasSecurityAttributes) /// this should always be true, but just in case
{
List<SecurityAttribute> securityAttributes = new List<SecurityAttribute>(declaration.SecurityAttributes);
securityAttributes.Sort((x, y) => x.CompareToSecurityAttribute(y, declaration, declaration));
foreach (SecurityAttribute attr in securityAttributes)
{
WriteSingleSecurityAttributes(attr);
WriteLine();
}
}
Outdent();
WriteEndBreckets();
}
protected virtual void MarkSecurityDeclaration (SecurityDeclaration sd)
{
if (!sd.HasSecurityAttributes)
return;
foreach (var sa in sd.SecurityAttributes)
MarkSecurityAttribute (sa);
}
private bool WriteSecurityAttribute(ModuleDefinition module, bool isAssemblyDeclaration, SecurityAttribute attribute, SecurityDeclaration securityDeclaration, out bool wroteArgument)
{
genericWriter.WriteToken(OpeningBracket);
if (isAssemblyDeclaration)
{
genericWriter.WriteKeyword(genericWriter.KeyWordWriter.Assembly);
genericWriter.Write(":");
genericWriter.WriteSpace();
}
string attributeName = attribute.AttributeType.Name.EndsWith("Attribute") ? attribute.AttributeType.Name.Remove(attribute.AttributeType.Name.LastIndexOf("Attribute")) : attribute.AttributeType.Name;
genericWriter.WriteNamespaceIfTypeInCollision(attribute.AttributeType);
genericWriter.WriteReference(attributeName, attribute.AttributeType);
genericWriter.WriteToken("(");
TypeReference securityActionTypeReference = securityDeclaration.GetSecurityActionTypeReference(module);
TypeDefinition argumentTypeDefinition = securityActionTypeReference.IsDefinition ? securityActionTypeReference as TypeDefinition : securityActionTypeReference.Resolve();
if (argumentTypeDefinition != null && argumentTypeDefinition.IsEnum)
{
List<FieldDefinition> fields = EnumValueToFieldCombinationMatcher.GetEnumFieldDefinitionByValue(argumentTypeDefinition.Fields, (int)securityDeclaration.Action, argumentTypeDefinition.CustomAttributes);
if (fields.Count != 0)
{
for (int i = 0; i < fields.Count; i++)
{
genericWriter.WriteReferenceAndNamespaceIfInCollision(fields[i].DeclaringType);
genericWriter.WriteToken(".");
genericWriter.WriteEnumValueField(fields[i]);
if (i + 1 < fields.Count)
{
genericWriter.WriteSpace();
genericWriter.WriteBitwiseOr();
genericWriter.WriteSpace();
}
}
}
else
{
WriteSecurityAttributeAction(securityDeclaration.Action);
}
}
wroteArgument = true;
if (attribute.HasFields || attribute.HasProperties)
{
var attributeType = attribute.AttributeType.Resolve();
if (attribute.HasProperties)
{
wroteArgument = WriteAttributeNamedArgs(attributeType, attribute.Properties, false, wroteArgument);
}
if (attribute.HasFields)
{
WriteAttributeNamedArgs(attributeType, attribute.Fields, true, wroteArgument);
}
}
genericWriter.WriteToken(")");
genericWriter.WriteToken(ClosingBracket);
genericWriter.WriteLine();
return wroteArgument;
}
public SecurityDeclarationEventArgs(SecurityDeclaration item)
{
m_item = item;
}
public bool Contains(SecurityDeclaration value)
{
if (value == null)
return (m_items.Count == 0);
SecurityDeclaration item = (SecurityDeclaration) m_items[value.Action];
if (item == null)
return false;
#if !CF_1_0 && !CF_2_0
return value.PermissionSet.IsSubsetOf (item.PermissionSet);
#else
// XXX For CF, this concept does not exist--so always be true
return true;
#endif
}
public static void InjectSecurityDeclaration(this ISecurityDeclarationProvider target, SecurityDeclaration declaration, ReferenceResolver resolver)
{
var newDeclaration = new SecurityDeclaration(declaration.Action);
MetadataBuilderHelper.CopySecurityAttributes(declaration, newDeclaration, resolver);
target.SecurityDeclarations.Add(newDeclaration);
}
private int CompareSecurityDeclaration(SecurityDeclaration first, SecurityDeclaration second)
{
if (first == second)
{
return 0;
}
string firstKeyword = GetActionKeyword(first.Action);
string secondKeyword = GetActionKeyword(second.Action);
return firstKeyword.CompareTo(secondKeyword);
}
public byte[] GetAsByteArray(SecurityDeclaration dec)
{
// TODO - add support for 2.0 format
// note: the 1.x format is still supported in 2.0 so this isn't an immediate problem
if (!dec.IsReadable)
return dec.Blob;
#if !CF_1_0 && !CF_2_0
if (dec.PermissionSet != null)
return Encoding.Unicode.GetBytes (dec.PermissionSet.ToXml ().ToString ());
#endif
return new byte [0];
}
void addSecurityDeclaration(SecurityDeclaration decl)
{
if (decl == null)
return;
access(() => addSecurityAttributes(decl.SecurityAttributes));
}
public SecurityDeclaration FromByteArray(SecurityAction action, byte [] declaration, bool resolve)
{
SecurityDeclaration dec = new SecurityDeclaration(action, this);
#if !CF_1_0 && !CF_2_0
dec.PermissionSet = new PermissionSet(SSP.PermissionState.None);
if (IsEmptyDeclaration(declaration))
{
return(dec);
}
if (declaration[0] == 0x2e)
{
// new binary format introduced in 2.0
int pos = 1;
int start;
int numattr = Utilities.ReadCompressedInteger(declaration, pos, out start);
if (numattr == 0)
{
return(dec);
}
BinaryReader br = new BinaryReader(new MemoryStream(declaration));
for (int i = 0; i < numattr; i++)
{
pos = start;
SSP.SecurityAttribute sa = CreateSecurityAttribute(action, br, declaration, pos, out start, resolve);
if (sa == null)
{
dec.Resolved = false;
dec.Blob = declaration;
return(dec);
}
try {
IPermission p = sa.CreatePermission();
dec.PermissionSet.AddPermission(p);
} catch {
dec.Resolved = false;
dec.Blob = declaration;
return(dec);
}
}
dec.Resolved = true;
}
else
{
Parser.LoadXml(Encoding.Unicode.GetString(declaration));
try {
dec.PermissionSet.FromXml(Parser.ToXml());
dec.PermissionSet.ToXml();
dec.Resolved = true;
} catch {
dec.Resolved = false;
dec.Blob = declaration;
}
}
#endif
return(dec);
}