private static bool TryProcessPermissionSetAttribute(SecurityDeclaration declaration, out PermissionSet set)
{
set = null;
if (!declaration.HasSecurityAttributes && declaration.SecurityAttributes.Count != 1)
{
return(false);
}
Mono.Cecil.SecurityAttribute item = declaration.SecurityAttributes[0];
if (!item.AttributeType.IsTypeOf("System.Security.Permissions", "PermissionSetAttribute"))
{
return(false);
}
PermissionSetAttribute permissionSetAttribute = new PermissionSetAttribute((System.Security.Permissions.SecurityAction)declaration.Action);
Mono.Cecil.CustomAttributeNamedArgument customAttributeNamedArgument = item.Properties[0];
string value = (string)customAttributeNamedArgument.Argument.Value;
string name = customAttributeNamedArgument.Name;
if (name == "XML")
{
permissionSetAttribute.XML = value;
}
else
{
if (name != "Name")
{
throw new NotImplementedException(customAttributeNamedArgument.Name);
}
permissionSetAttribute.Name = value;
}
set = permissionSetAttribute.CreatePermissionSet();
return(true);
}
public static void InjectSecurityAttribute(this SecurityDeclaration target, SecurityAttribute attribute, ReferenceResolver resolver)
{
var attributeType = resolver.ReferenceType(attribute.AttributeType);
var newAttribute = new SecurityAttribute(attributeType);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields, resolver);
MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties, resolver);
target.SecurityAttributes.Add(newAttribute);
}
private static IPermission CreatePermission(SecurityDeclaration declaration, Mono.Cecil.SecurityAttribute attribute)
{
Type type = Type.GetType(attribute.AttributeType.FullName);
if (type == null)
{
throw new ArgumentException("attribute");
}
System.Security.Permissions.SecurityAttribute securityAttribute = SecurityDeclarationRocks.CreateSecurityAttribute(type, declaration);
if (securityAttribute == null)
{
throw new InvalidOperationException();
}
SecurityDeclarationRocks.CompleteSecurityAttribute(securityAttribute, attribute);
return(securityAttribute.CreatePermission());
}
public static SecurityDeclaration ToSecurityDeclaration(this PermissionSet self, Mono.Cecil.SecurityAction action, ModuleDefinition module)
{
if (self == null)
{
throw new ArgumentNullException("self");
}
if (module == null)
{
throw new ArgumentNullException("module");
}
SecurityDeclaration securityDeclaration = new SecurityDeclaration(action);
Mono.Cecil.SecurityAttribute securityAttribute = new Mono.Cecil.SecurityAttribute(module.TypeSystem.LookupType("System.Security.Permissions", "PermissionSetAttribute"));
securityAttribute.Properties.Add(new Mono.Cecil.CustomAttributeNamedArgument("XML", new CustomAttributeArgument(module.TypeSystem.String, self.ToXml().ToString())));
securityDeclaration.SecurityAttributes.Add(securityAttribute);
return(securityDeclaration);
}
private void WriteSecurityAttribute(SecurityAttribute attribute)
{
this.WriteTypeReference(attribute.AttributeType);
int namedArgumentCount = SignatureWriter.GetNamedArgumentCount(attribute);
if (namedArgumentCount == 0)
{
base.WriteCompressedUInt32(1);
base.WriteCompressedUInt32(0);
return;
}
SignatureWriter signatureWriter = new SignatureWriter(this.metadata);
signatureWriter.WriteCompressedUInt32((uint)namedArgumentCount);
signatureWriter.WriteICustomAttributeNamedArguments(attribute);
base.WriteCompressedUInt32((uint)signatureWriter.length);
base.WriteBytes(signatureWriter);
}
private static string GetXmlSecurityDeclaration(SecurityDeclaration declaration)
{
if ((declaration.security_attributes == null) || (declaration.security_attributes.Count != 1))
{
return(null);
}
SecurityAttribute attribute = declaration.security_attributes[0];
if (!attribute.AttributeType.IsTypeOf("System.Security.Permissions", "PermissionSetAttribute"))
{
return(null);
}
if ((attribute.properties == null) || (attribute.properties.Count != 1))
{
return(null);
}
CustomAttributeNamedArgument argument = attribute.properties[0];
return((argument.Name == "XML") ? ((string)argument.Argument.Value) : null);
}
private static string GetXmlSecurityDeclaration(SecurityDeclaration declaration)
{
if (declaration.security_attributes != null && declaration.security_attributes.Count == 1)
{
SecurityAttribute securityAttribute = declaration.security_attributes[0];
if (!securityAttribute.AttributeType.IsTypeOf("System.Security.Permissions", "PermissionSetAttribute"))
{
return(null);
}
if (securityAttribute.properties != null && securityAttribute.properties.Count == 1)
{
CustomAttributeNamedArgument customAttributeNamedArgument = securityAttribute.properties[0];
if (customAttributeNamedArgument.Name != "XML")
{
return(null);
}
return((string)customAttributeNamedArgument.Argument.Value);
}
return(null);
}
return(null);
}
private static string GetXmlSecurityDeclaration(SecurityDeclaration declaration)
{
if (declaration.security_attributes == null || declaration.security_attributes.Count != 1)
{
return(null);
}
SecurityAttribute item = declaration.security_attributes[0];
if (!item.AttributeType.IsTypeOf("System.Security.Permissions", "PermissionSetAttribute"))
{
return(null);
}
if (item.properties == null || item.properties.Count != 1)
{
return(null);
}
CustomAttributeNamedArgument customAttributeNamedArgument = item.properties[0];
if (customAttributeNamedArgument.Name != "XML")
{
return(null);
}
return((string)customAttributeNamedArgument.Argument.Value);
}
void addSecurityAttribute(SecurityAttribute attr)
{
if (attr == null)
return;
pushMember(attr.AttributeType);
addCustomAttributeNamedArguments(attr.Fields);
addCustomAttributeNamedArguments(attr.Properties);
}
private void WriteSingleSecurityAttributes(SecurityAttribute attribute)
{
WriteType(attribute.AttributeType, ILNameSyntax.TypeName);
if (attribute.HasProperties)
{
WriteSpace();
Write("=");
WriteLine();
WriteOpenBreckets();
WriteLine();
Indent();
foreach (CustomAttributeNamedArgument property in attribute.Properties)
{
WriteKeyword("property");
WriteSpace();
WriteType(property.Argument.Type, ILNameSyntax.TypeName);
WriteSpace();
WriteLiteral("'");
WriteLiteral(property.Name);
WriteLiteral("'");
WriteSpace();
Write("=");
WriteSpace();
WriteType(property.Argument.Type, ILNameSyntax.TypeName);
WriteSpace();
Write("(");
if (property.Argument.Value is bool)
{
WriteBooleanLiteral((bool)property.Argument.Value);
}
else if (property.Argument.Value is string)
{
WriteStringLiteral((string)property.Argument.Value);
}
else
{
WriteLiteral(property.Argument.Value.ToString());
}
Write(")");
WriteLine();
}
Outdent();
WriteEndBreckets();
}
}
protected void MarkSecurityAttributeFields (SecurityAttribute sa, TypeDefinition attribute)
{
if (!sa.HasFields)
return;
foreach (var named_argument in sa.Fields)
MarkCustomAttributeField (named_argument, attribute);
}
protected void MarkSecurityAttributeProperties (SecurityAttribute sa, TypeDefinition attribute)
{
if (!sa.HasProperties)
return;
foreach (var named_argument in sa.Properties)
MarkCustomAttributeProperty (named_argument, attribute);
}
protected virtual void MarkSecurityAttribute (SecurityAttribute sa)
{
TypeReference security_type = sa.AttributeType;
TypeDefinition type = security_type.Resolve ();
if (type == null)
throw new ResolutionException (security_type);
MarkType (security_type);
MarkSecurityAttributeProperties (sa, type);
MarkSecurityAttributeFields (sa, type);
}
private static void CompleteSecurityAttributeProperties(System.Security.Permissions.SecurityAttribute security_attribute, Mono.Cecil.SecurityAttribute attribute)
{
Type type = security_attribute.GetType();
foreach (Mono.Cecil.CustomAttributeNamedArgument property in attribute.Properties)
{
type.GetProperty(property.Name).SetValue(security_attribute, property.Argument.Value, null);
}
}
private static void CompleteSecurityAttribute(System.Security.Permissions.SecurityAttribute security_attribute, Mono.Cecil.SecurityAttribute attribute)
{
if (attribute.HasFields)
{
SecurityDeclarationRocks.CompleteSecurityAttributeFields(security_attribute, attribute);
}
if (attribute.HasProperties)
{
SecurityDeclarationRocks.CompleteSecurityAttributeProperties(security_attribute, attribute);
}
}
private static void CompleteSecurityAttributeFields(System.Security.Permissions.SecurityAttribute security_attribute, Mono.Cecil.SecurityAttribute attribute)
{
Type type = security_attribute.GetType();
foreach (Mono.Cecil.CustomAttributeNamedArgument field in attribute.Fields)
{
type.GetField(field.Name).SetValue(security_attribute, field.Argument.Value);
}
}
private int CompareSecurityAttributes(SecurityAttribute first, SecurityAttribute second)
{
if (first == second)
{
return 0;
}
SecurityDeclaration firstDeclaration = securityAttributeToDeclaration[first];
SecurityDeclaration secondDeclaration = securityAttributeToDeclaration[second];
return first.CompareToSecurityAttribute(second, firstDeclaration, secondDeclaration);
}
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;
}
private static ICollection<TypeReference> GetSecurityAttributeUsedTypes(SecurityAttribute attribute)
{
List<TypeReference> typesDependingOn = new List<TypeReference>();
typesDependingOn.Add(attribute.AttributeType);
if (attribute.HasFields || attribute.HasProperties)
{
var attributeType = attribute.AttributeType.Resolve();
if (attribute.HasProperties)
{
typesDependingOn.AddRange(GetAttributeNamedArgsUsedTypes(attributeType, attribute.Properties, false));
}
if (attribute.HasFields)
{
typesDependingOn.AddRange(GetAttributeNamedArgsUsedTypes(attributeType, attribute.Fields, true));
}
}
return typesDependingOn;
}
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;
}
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);
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;
}
