Esempio n. 1
0
        /// <summary>
        /// Processes the assembly - goes through each member and applies a mapping.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="definition">The assembly definition.</param>
        private static void ProcessAssembly(ICloakContext context, AssemblyDefinition definition)
        {
            //Store whether to obfuscate all members
            bool obfuscateAll = context.Settings.ObfuscateAllModifiers;

            //Set up the mapping graph
            AssemblyMapping assemblyMapping = context.MappingGraph.AddAssembly(definition);

            //Get a reference to the name manager
            NameManager nameManager = context.NameManager;

            //Go through each module
            foreach (ModuleDefinition moduleDefinition in definition.Modules)
            {
                //Go through each type
                foreach (TypeDefinition typeDefinition in moduleDefinition.GetAllTypes())
                {
                    //First of all - see if we've declared it already - if so get the existing reference
                    TypeMapping typeMapping = assemblyMapping.GetTypeMapping(typeDefinition);
                    if (typeMapping == null)
                    {
                        //We don't have it - get it
                        if (obfuscateAll)
                        {
                            typeMapping = assemblyMapping.AddType(typeDefinition,
                                                                  nameManager.GenerateName(NamingTable.Type));
                        }
                        else
                        {
                            typeMapping = assemblyMapping.AddType(typeDefinition, null);
                        }
                    }

                    //Go through each method
                    foreach (MethodDefinition methodDefinition in typeDefinition.Methods)
                    {
                        //First of all - check if we've obfuscated it already - if we have then don't bother
                        if (typeMapping.HasMethodBeenObfuscated(methodDefinition.Name))
                        {
                            continue;
                        }

                        //We won't do constructors - causes issues
                        if (methodDefinition.IsConstructor)
                        {
                            continue;
                        }

                        //We haven't - let's work out the obfuscated name
                        if (obfuscateAll)
                        {
                            //Take into account whether this is overriden, or an interface implementation
                            if (methodDefinition.IsVirtual)
                            {
                                //We handle this differently - rather than creating a new name each time we need to reuse any already generated names
                                //We do this by firstly finding the root interface or object
                                TypeDefinition baseType = FindBaseTypeDeclaration(typeDefinition, methodDefinition);
                                if (baseType != null)
                                {
                                    //Find it in the mappings
                                    TypeMapping baseTypeMapping = assemblyMapping.GetTypeMapping(baseType);
                                    if (baseTypeMapping != null)
                                    {
                                        //We found the type mapping - look up the name it uses for this method and use that
                                        if (baseTypeMapping.HasMethodMapping(methodDefinition))
                                        {
                                            typeMapping.AddMethodMapping(methodDefinition, baseTypeMapping.GetObfuscatedMethodName(methodDefinition));
                                        }
                                        else
                                        {
                                            //That's strange... we shouldn't get into here - but if we ever do then
                                            //we'll add the type mapping into both
                                            string obfuscatedName = nameManager.GenerateName(NamingTable.Method);
                                            typeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                                            baseTypeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                                        }
                                    }
                                    else
                                    {
                                        //Otherwise add it into our list manually
                                        //at the base level first off
                                        baseTypeMapping = assemblyMapping.AddType(baseType,
                                                                                  nameManager.GenerateName(NamingTable.Type));
                                        string obfuscatedName = nameManager.GenerateName(NamingTable.Method);
                                        baseTypeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                                        //Now at our implemented level
                                        typeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                                    }
                                }
                                else
                                {
                                    //We must be at the base already - add normally
                                    typeMapping.AddMethodMapping(methodDefinition,
                                                                 nameManager.GenerateName(NamingTable.Method));
                                }
                            }
                            else //Add normally
                            {
                                typeMapping.AddMethodMapping(methodDefinition,
                                                             nameManager.GenerateName(NamingTable.Method));
                            }
                        }
                        else if (methodDefinition.IsPrivate)
                        {
                            typeMapping.AddMethodMapping(methodDefinition, nameManager.GenerateName(NamingTable.Method));
                        }
                    }

                    //Properties
                    foreach (PropertyDefinition propertyDefinition in typeDefinition.Properties)
                    {
                        //First of all - check if we've obfuscated it already - if we have then don't bother
                        if (typeMapping.HasPropertyBeenObfuscated(propertyDefinition.Name))
                        {
                            continue;
                        }

                        //Go through the old fashioned way
                        if (obfuscateAll)
                        {
                            if ((propertyDefinition.GetMethod != null && propertyDefinition.GetMethod.IsVirtual) ||
                                (propertyDefinition.SetMethod != null && propertyDefinition.SetMethod.IsVirtual))
                            {
                                //We handle this differently - rather than creating a new name each time we need to reuse any already generated names
                                //We do this by firstly finding the root interface or object
                                TypeDefinition baseType = FindBaseTypeDeclaration(typeDefinition, propertyDefinition);
                                if (baseType != null)
                                {
                                    //Find it in the mappings
                                    TypeMapping baseTypeMapping = assemblyMapping.GetTypeMapping(baseType);
                                    if (baseTypeMapping != null)
                                    {
                                        //We found the type mapping - look up the name it uses for this property and use that
                                        if (baseTypeMapping.HasPropertyMapping(propertyDefinition))
                                        {
                                            typeMapping.AddPropertyMapping(propertyDefinition, baseTypeMapping.GetObfuscatedPropertyName(propertyDefinition));
                                        }
                                        else
                                        {
                                            //That's strange... we shouldn't get into here - but if we ever do then
                                            //we'll add the type mapping into both
                                            string obfuscatedName = nameManager.GenerateName(NamingTable.Property);
                                            typeMapping.AddPropertyMapping(propertyDefinition, obfuscatedName);
                                            baseTypeMapping.AddPropertyMapping(propertyDefinition, obfuscatedName);
                                        }
                                    }
                                    else
                                    {
                                        //Otherwise add it into our list manually
                                        //at the base level first off
                                        baseTypeMapping = assemblyMapping.AddType(baseType,
                                                                                  nameManager.GenerateName(NamingTable.Type));
                                        string obfuscatedName = nameManager.GenerateName(NamingTable.Property);
                                        baseTypeMapping.AddPropertyMapping(propertyDefinition, obfuscatedName);
                                        //Now at our implemented level
                                        typeMapping.AddPropertyMapping(propertyDefinition, obfuscatedName);
                                    }
                                }
                                else
                                {
                                    //We must be at the base already - add normally
                                    typeMapping.AddPropertyMapping(propertyDefinition,
                                                                   nameManager.GenerateName(NamingTable.Property));
                                }
                            }
                            else
                            {
                                typeMapping.AddPropertyMapping(propertyDefinition,
                                                               nameManager.GenerateName(NamingTable.Property));
                            }
                        }
                        else if (propertyDefinition.GetMethod != null && propertyDefinition.SetMethod != null)
                        {
                            //Both parts need to be private
                            if (propertyDefinition.GetMethod.IsPrivate && propertyDefinition.SetMethod.IsPrivate)
                            {
                                typeMapping.AddPropertyMapping(propertyDefinition, nameManager.GenerateName(NamingTable.Property));
                            }
                        }
                        else if (propertyDefinition.GetMethod != null)
                        {
                            //Only the get is present - make sure it is private
                            if (propertyDefinition.GetMethod.IsPrivate)
                            {
                                typeMapping.AddPropertyMapping(propertyDefinition, nameManager.GenerateName(NamingTable.Property));
                            }
                        }
                        else if (propertyDefinition.SetMethod != null)
                        {
                            //Only the set is present - make sure it is private
                            if (propertyDefinition.SetMethod.IsPrivate)
                            {
                                typeMapping.AddPropertyMapping(propertyDefinition, nameManager.GenerateName(NamingTable.Property));
                            }
                        }
                    }

                    //Fields
                    foreach (FieldDefinition fieldDefinition in typeDefinition.Fields)
                    {
                        //First of all - check if we've obfuscated it already - if we have then don't bother
                        if (typeMapping.HasFieldBeenObfuscated(fieldDefinition.Name))
                        {
                            continue;
                        }

                        if (obfuscateAll)
                        {
                            typeMapping.AddFieldMapping(fieldDefinition, nameManager.GenerateName(NamingTable.Field));
                        }
                        else if (fieldDefinition.IsPrivate)
                        {
                            //Rename if private
                            typeMapping.AddFieldMapping(fieldDefinition, nameManager.GenerateName(NamingTable.Field));
                        }
                    }
                }
            }
        }
Esempio n. 2
0
        private void MapMethod(AssemblyMapping assemblyMapping, TypeDefinition typeDefinition, TypeMapping typeMapping, MethodDefinition methodDefinition)
        {
            //First of all - check if we've obfuscated it already - if we have then don't bother
            if (typeMapping.HasMethodBeenObfuscated(methodDefinition.Name))
            {
                return;
            }

            //We won't do constructors - causes issues
            if (methodDefinition.IsConstructor)
            {
                return;
            }

            //We haven't - let's work out the obfuscated name
            if (context.Settings.ObfuscateAllModifiers)
            {
                //Take into account whether this is overriden, or an interface implementation
                if (methodDefinition.IsVirtual)
                {
                    //We handle this differently - rather than creating a new name each time we need to reuse any already generated names
                    //We do this by firstly finding the root interface or object
                    TypeDefinition baseType = FindBaseTypeDeclaration(typeDefinition, methodDefinition);
                    if (baseType != null)
                    {
                        //Find it in the mappings
                        TypeMapping baseTypeMapping = assemblyMapping.GetTypeMapping(baseType);
                        if (baseTypeMapping != null)
                        {
                            //We found the type mapping - look up the name it uses for this method and use that
                            if (baseTypeMapping.HasMethodMapping(methodDefinition))
                            {
                                typeMapping.AddMethodMapping(methodDefinition, baseTypeMapping.GetObfuscatedMethodName(methodDefinition));
                            }
                            else
                            {
                                //That's strange... we shouldn't get into here - but if we ever do then
                                //we'll add the type mapping into both
                                string obfuscatedName = context.NameManager.GenerateName(NamingTable.Method);
                                typeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                                baseTypeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                            }
                        }
                        else
                        {
                            //Otherwise add it into our list manually
                            //at the base level first off
                            baseTypeMapping = assemblyMapping.AddType(baseType,
                                                                      context.NameManager.GenerateName(NamingTable.Type));
                            string obfuscatedName = context.NameManager.GenerateName(NamingTable.Method);
                            baseTypeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                            //Now at our implemented level
                            typeMapping.AddMethodMapping(methodDefinition, obfuscatedName);
                        }
                    }
                    else
                    {
                        //We must be at the base already - add normally
                        typeMapping.AddMethodMapping(methodDefinition,
                                                     context.NameManager.GenerateName(NamingTable.Method));
                    }
                }
                else //Add normally
                {
                    typeMapping.AddMethodMapping(methodDefinition,
                                                 context.NameManager.GenerateName(NamingTable.Method));
                }
            }
            else if (methodDefinition.IsPrivate)
            {
                typeMapping.AddMethodMapping(methodDefinition, context.NameManager.GenerateName(NamingTable.Method));
            }
        }