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; }