示例#1
0
        public void DataElementAttributes()
        {
            var errors = new StringBuilder();

            var deByType = new Dictionary <Type, DataElementAttribute>();
            var deByName = new Dictionary <string, KeyValuePair <DataElementAttribute, Type> >();

            foreach (var kv in ClassLoader.GetAllByAttribute <DataElementAttribute>(null))
            {
                var attr = kv.Key;
                var type = kv.Value;

                // Verify only 1 DataElement attribute per type
                if (deByType.ContainsKey(type))
                {
                    var old = deByType[type];

                    errors.AppendLine();
                    errors.AppendFormat("DataElement in assembly '{0}' class '{1}' declared both '{2}' and '{3}.",
                                        type.Assembly.Location, type.FullName, attr.elementName, old.elementName);
                }
                else
                {
                    deByType.Add(type, attr);
                }

                // Verify no elementName collissions
                if (deByName.ContainsKey(attr.elementName))
                {
                    var old = deByName[attr.elementName];

                    errors.AppendLine();
                    errors.AppendFormat("DataElement '{0}' declared in assembly '{1}' class '{2}' and in assembly {3} and class '{4}'.",
                                        attr.elementName, kv.Value.Assembly.Location, kv.Value.FullName, old.Value.Assembly.Location, old.Value.FullName);
                }
                else
                {
                    deByName.Add(attr.elementName, kv);
                }

                var paramAttrs = type.GetAttributes <ParameterAttribute>(null).Select(a => a.name).ToList();
                var dupes      = paramAttrs.GroupBy(a => a).SelectMany(g => g.Skip(1)).Distinct().ToList();
                if (dupes.Count != 0)
                {
                    errors.AppendLine();
                    errors.AppendFormat("DataElement '{0}' declared in assembly '{1}' class '{2}' has duplicate parameters: '{3}'",
                                        attr.elementName, type.Assembly.Location, type.FullName, string.Join("', '", dupes));
                }
            }

            string msg = errors.ToString();

            if (!string.IsNullOrEmpty(msg))
            {
                logger.Debug(msg);
                Assert.Null(msg);
            }
        }
示例#2
0
        private XmlSchemaElement[] MakeDataModel(string minOccurs, string maxOccurrs)
        {
            var ret = new List <XmlSchemaElement>();

            foreach (var item in ClassLoader.GetAllByAttribute <PitParsableAttribute>((t, a) => a.topLevel))
            {
                var name = item.Key.xmlElementName;
                var type = item.Value;

                var elem = MakeDataElement(name, type);
                elem.MinOccursString = minOccurs;
                elem.MaxOccursString = maxOccurrs;

                ret.Add(elem);
            }

            return(ret.ToArray());
        }
示例#3
0
        public FormMain()
        {
            InitializeComponent();

            foreach (var strategy in ClassLoader.GetAllByAttribute <MutationStrategyAttribute>(null))
            {
                comboBoxFuzzingStrategy.Items.Add(strategy.Key.Name);
            }

            //tabControl.TabPages.Remove(tabPageGUI);
            tabControl.TabPages.Remove(tabPageFuzzing);
            //tabControl.TabPages.Remove(tabPageOutput);

            LoadPlatformAssembly();

            // Check OS and load side assembly
            Platform.OS os = Platform.GetOS();

            switch (os)
            {
            case Platform.OS.OSX:
                tabControl.TabPages.Remove(tabPageDebuggerLinux);
                tabControl.TabPages.Remove(tabPageDebuggerWin);
                tabControl.TabPages.Remove(tabPageGUI);
                richTextBoxOSX.LoadFile(Assembly.GetExecutingAssembly().GetManifestResourceStream("PeachFuzzBang.OSXDebugging.rtf"), RichTextBoxStreamType.RichText);
                break;

            case Platform.OS.Linux:
                tabControl.TabPages.Remove(tabPageDebuggerOSX);
                tabControl.TabPages.Remove(tabPageDebuggerWin);
                tabControl.TabPages.Remove(tabPageGUI);
                richTextBoxLinux.LoadFile(Assembly.GetExecutingAssembly().GetManifestResourceStream("PeachFuzzBang.LinuxDebugging.rtf"), RichTextBoxStreamType.RichText);
                break;

            case Platform.OS.Windows:
            {
                comboBoxAttachToServiceServices.Items.Clear();
                foreach (ServiceController srv in ServiceController.GetServices())
                {
                    comboBoxAttachToServiceServices.Items.Add(srv.ServiceName);
                }

                textBoxAttachToProcessProcessName.Items.Clear();
                foreach (Process proc in Process.GetProcesses())
                {
                    textBoxAttachToProcessProcessName.Items.Add(proc.ProcessName);
                    proc.Close();
                }

                tabControl.TabPages.Remove(tabPageDebuggerOSX);
                tabControl.TabPages.Remove(tabPageDebuggerLinux);

                if (!Environment.Is64BitProcess && Environment.Is64BitOperatingSystem)
                {
                    MessageBox.Show("Warning: The 64bit version of Peach 3 must be used on 64 bit Operating Systems.", "Warning");
                }

                string windbg = null;
                Type   t      = ClassLoader.FindTypeByAttribute <MonitorAttribute>((x, y) => y.Name == "WindowsDebugger");
                if (t != null)
                {
                    windbg = t.InvokeMember("FindWinDbg", BindingFlags.InvokeMethod, null, null, null) as string;
                }

                if (windbg != null)
                {
                    textBoxDebuggerPath.Text = windbg;
                }
                else
                {
                    textBoxDebuggerPath.Text = "Error, could not locate windbg!";
                }
            }
            break;
            }

            if (os != Platform.OS.Windows)
            {
                // Update default settings to include full path to PeachFuzzBang
                // When double clicking the app to run it, the current working
                // directory is $HOME
                string cwd  = Environment.CurrentDirectory + Path.DirectorySeparatorChar;
                string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar;

                if (path.StartsWith(cwd))
                {
                    path = path.Substring(cwd.Length);
                }

                if (!string.IsNullOrEmpty(path))
                {
                    textBoxFuzzedFile.Text     = Path.Combine(path, textBoxFuzzedFile.Text);
                    textBoxTemplateFiles.Text  = Path.Combine(path, textBoxTemplateFiles.Text);
                    textBoxLinuxArguments.Text = Path.Combine(path, textBoxLinuxArguments.Text);
                    textBoxOSXArguments.Text   = Path.Combine(path, textBoxOSXArguments.Text);
                }
            }

            buttonStartFuzzing.Enabled      = true;
            buttonSaveConfiguration.Enabled = false;
            buttonStopFuzzing.Enabled       = false;

            comboBoxPitDataModel.SelectedIndexChanged += new EventHandler(comboBoxPitDataModel_SelectedIndexChanged);

            richTextBoxIntroduction.LoadFile(Assembly.GetExecutingAssembly().GetManifestResourceStream("PeachFuzzBang.Introduction.rtf"), RichTextBoxStreamType.RichText);
        }
示例#4
0
        void PopulatePluginType(XmlSchemaComplexType complexType, PluginElementAttribute pluginAttr)
        {
            if (pluginAttr.Named)
            {
                var nameAttr = new XmlSchemaAttribute();
                nameAttr.Name = "name";
                nameAttr.Annotate("{0} name.".Fmt(pluginAttr.PluginType.Name));
                nameAttr.Use = XmlSchemaUse.Optional;

                complexType.Attributes.Add(nameAttr);
            }

            var typeAttr = new XmlSchemaAttribute();

            typeAttr.Name = pluginAttr.AttributeName;
            typeAttr.Use  = XmlSchemaUse.Required;
            typeAttr.Annotate("Specify the class name of a Peach {0}. You can implement your own {1}s as needed.".Fmt(
                                  pluginAttr.PluginType.Name,
                                  pluginAttr.PluginType.Name.ToLower()
                                  ));

            var restrictEnum = new XmlSchemaSimpleTypeRestriction();

            restrictEnum.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace);

            foreach (var item in ClassLoader.GetAllByAttribute <PluginAttribute>((t, a) => a.Type == pluginAttr.PluginType && a.IsDefault && !a.IsTest))
            {
                restrictEnum.Facets.Add(MakePluginFacet(item.Key, item.Value));
            }

            var enumType = new XmlSchemaSimpleType();

            enumType.Content = restrictEnum;

            var restrictLen = new XmlSchemaSimpleTypeRestriction();

            restrictLen.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace);
            restrictLen.Facets.Add(new XmlSchemaMaxLengthFacet()
            {
                Value = "1024"
            });

            var userType = new XmlSchemaSimpleType();

            userType.Content = restrictLen;

            var union = new XmlSchemaSimpleTypeUnion();

            union.BaseTypes.Add(userType);
            union.BaseTypes.Add(enumType);

            var schemaType = new XmlSchemaSimpleType();

            schemaType.Content = union;

            typeAttr.SchemaType = schemaType;

            complexType.Attributes.Add(typeAttr);

            if (!objElemCache.ContainsKey(typeof(PluginParam)))
            {
                AddElement("Param", typeof(PluginParam), null);
            }


            var schemaElem = new XmlSchemaElement();

            schemaElem.RefName = new XmlQualifiedName("Param", schema.TargetNamespace);

            XmlSchemaGroupBase schemaParticle;

            if (pluginAttr.PluginType == typeof(Transformer))
            {
                schemaParticle = new XmlSchemaChoice();
                schemaParticle.MinOccursString = "0";
                schemaParticle.MaxOccursString = "unbounded";

                var transElem = new XmlSchemaElement();
                transElem.RefName = new XmlQualifiedName("Transformer", schema.TargetNamespace);
                schemaParticle.Items.Add(transElem);
            }
            else
            {
                schemaParticle             = new XmlSchemaSequence();
                schemaElem.MinOccursString = "0";
                schemaElem.MaxOccursString = "unbounded";
            }

            schemaParticle.Items.Add(schemaElem);

            complexType.Particle = schemaParticle;
        }
示例#5
0
        void CombinePluginType(XmlSchemaComplexType complexType, PluginElementAttribute pluginAttr)
        {
            var addedAttrs = new Dictionary <string, XmlSchemaAttribute>();
            var addedElems = new Dictionary <string, XmlSchemaElement>();

            var schemaParticle = new XmlSchemaChoice();

            schemaParticle.MinOccursString = "0";
            schemaParticle.MaxOccursString = "unbounded";

            var restrictEnum = new XmlSchemaSimpleTypeRestriction();

            restrictEnum.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace);

            foreach (var item in ClassLoader.GetAllByAttribute <PluginAttribute>((t, a) => a.Type == pluginAttr.PluginType && a.IsDefault && !a.IsTest))
            {
                restrictEnum.Facets.Add(MakePluginFacet(item.Key, item.Value));

                foreach (var pi in item.Value.GetProperties())
                {
                    var attrAttr = pi.GetAttributes <XmlAttributeAttribute>().FirstOrDefault();
                    if (attrAttr != null)
                    {
                        var attr = MakeAttribute(attrAttr.AttributeName, pi);
                        if (!addedAttrs.ContainsKey(attr.Name))
                        {
                            complexType.Attributes.Add(attr);
                            addedAttrs.Add(attr.Name, attr);
                        }
                        continue;
                    }

                    var elemAttr = pi.GetAttributes <XmlElementAttribute>().FirstOrDefault();
                    if (elemAttr != null)
                    {
                        var elems = MakeElement(elemAttr.ElementName, null, pi, null);
                        foreach (var elem in elems)
                        {
                            var key = elem.Name ?? elem.RefName.Name;
                            if (!addedElems.ContainsKey(key))
                            {
                                elem.MinOccursString = null;
                                elem.MaxOccursString = null;
                                schemaParticle.Items.Add(elem);
                                addedElems.Add(key, elem);
                            }
                        }
                    }

                    var anyAttr = pi.GetAttributes <XmlAnyAttributeAttribute>().FirstOrDefault();
                    if (anyAttr != null)
                    {
                        complexType.AnyAttribute = new XmlSchemaAnyAttribute()
                        {
                            ProcessContents = XmlSchemaContentProcessing.Skip
                        };
                        continue;
                    }
                }

                foreach (var prop in item.Value.GetAttributes <ParameterAttribute>())
                {
                    var attr = MakeAttribute(prop.name, prop);
                    if (!addedAttrs.ContainsKey(attr.Name))
                    {
                        complexType.Attributes.Add(attr);
                        addedAttrs.Add(attr.Name, attr);
                    }
                }
            }

            var enumType = new XmlSchemaSimpleType();

            enumType.Content = restrictEnum;

            var typeAttr = new XmlSchemaAttribute();

            typeAttr.Name       = pluginAttr.AttributeName;
            typeAttr.Use        = XmlSchemaUse.Required;
            typeAttr.SchemaType = enumType;
            typeAttr.Annotate("Specify the {0} of a Peach {1}.".Fmt(
                                  pluginAttr.AttributeName,
                                  pluginAttr.PluginType.Name.ToLower()
                                  ));

            complexType.Attributes.Add(typeAttr);

            if (schemaParticle.Items.Count > 0)
            {
                complexType.Particle = schemaParticle;
            }
        }
示例#6
0
        void AddDataElement(string name, Type type)
        {
            var schemaElem = MakeItem <XmlSchemaElement>(name, type, objElemCache);

            var complexType = new XmlSchemaComplexType();

            var schemaParticle = new XmlSchemaChoice();

            schemaParticle.MinOccursString = "0";
            schemaParticle.MaxOccursString = "unbounded";

            foreach (var prop in type.GetAttributes <ParameterAttribute>())
            {
                var attr = MakeAttribute(prop.name, prop);
                complexType.Attributes.Add(attr);
            }

            var deAttr = type.GetAttributes <Peach.Core.Dom.DataElementAttribute>().First();

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.DataElements))
            {
                foreach (var kv in ClassLoader.GetAllByAttribute <Peach.Core.Dom.DataElementAttribute>(null))
                {
                    var parents = kv.Value.GetAttributes <Peach.Core.Dom.DataElementParentSupportedAttribute>();
                    if (parents.Any() && !parents.Any(a => a.elementName == name))
                    {
                        continue;
                    }

                    var elem = MakeDataElement(kv.Key.elementName, kv.Value);
                    schemaParticle.Items.Add(elem);
                }
            }

            foreach (var child in type.GetAttributes <Peach.Core.Dom.DataElementChildSupportedAttribute>())
            {
                var childType = ClassLoader.FindTypeByAttribute <Peach.Core.Dom.DataElementAttribute>((t, a) => a.elementName == child.elementName);
                var elem      = MakeDataElement(child.elementName, childType);
                schemaParticle.Items.Add(elem);
            }

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.Fixup))
            {
                PopulateDataElement(schemaParticle, "Fixup");
            }

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.Hint))
            {
                var elems = MakeElement("Hint", null, typeof(DataModel).GetProperty("Hint"), null);

                foreach (var elem in elems)
                {
                    elem.MinOccursString = null;
                    elem.MaxOccursString = null;
                    schemaParticle.Items.Add(elem);
                }
            }

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.Transformer))
            {
                PopulateDataElement(schemaParticle, "Transformer");
            }

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.Relation))
            {
                PopulateDataElement(schemaParticle, "Relation");
            }

            if (deAttr.elementTypes.HasFlag(Peach.Core.Dom.DataElementTypes.Analyzer))
            {
                PopulateDataElement(schemaParticle, "Analyzer");
            }

            if (schemaParticle.Items.Count > 0)
            {
                complexType.Particle = schemaParticle;
            }

            schemaElem.SchemaType = complexType;
        }
示例#7
0
        public void PluginAttributes()
        {
            var errors = new StringBuilder();

            // All plugins should have:
            // 1) One plugin attribute with default=true
            // 2) A description
            // 3) No duplicated parameters
            // 4) No plugin attribute names should conflict
            // 5) Plugins can only be of one type (Monitor/Publisher/Fixup)

            var pluginsByType = new Dictionary <Type, List <PluginAttribute> >();
            var pluginsByName = new Dictionary <string, KeyValuePair <PluginAttribute, Type> >();

            foreach (var kv in ClassLoader.GetAllByAttribute <Peach.Core.PluginAttribute>(null))
            {
                var attr = kv.Key;
                var type = kv.Value;

                if (!pluginsByType.ContainsKey(type))
                {
                    pluginsByType.Add(type, new List <PluginAttribute>());
                }

                pluginsByType[type].Add(attr);

                string pluginName = string.Format("{0} '{1}'", attr.Type.Name, attr.Name);

                // Verify #4 (no name collisions)
                if (pluginsByName.ContainsKey(pluginName))
                {
                    var old = pluginsByName[pluginName];

                    errors.AppendLine();

                    if (old.Value == kv.Value)
                    {
                        errors.AppendFormat("{0} declared more than once in assembly '{1}' class '{2}'.",
                                            pluginName, kv.Value.Assembly.Location, kv.Value.FullName);
                    }
                    else
                    {
                        errors.AppendFormat("{0} declared in assembly '{1}' class '{2}' and in assembly {3} and class '{4}'.",
                                            pluginName, kv.Value.Assembly.Location, kv.Value.FullName, old.Value.Assembly.Location, old.Value.FullName);
                    }
                }
                else
                {
                    pluginsByName.Add(pluginName, kv);
                }
            }

            foreach (var kv in pluginsByType)
            {
                var type  = kv.Key;
                var attrs = kv.Value;

                // Verify #4 (eEnsure all plugin attributes are of the same type)
                var pluginTypes = attrs.Select(a => a.Type.Name).Distinct().ToList();
                if (pluginTypes.Count != 1)
                {
                    errors.AppendLine();
                    errors.AppendFormat("Plugin declared in assembly '{1}' class '{2}' has multiple types: '{3}'",
                                        attrs[0].Type.Name, type.Assembly.Location, type.FullName, string.Join("', '", pluginTypes));
                }

                // Verify #1 (ensure there is a single default)
                var defaults = attrs.Where(a => a.IsDefault).Select(a => a.Name).ToList();
                if (defaults.Count == 0)
                {
                    errors.AppendLine();
                    errors.AppendFormat("{0} declared in assembly '{1}' class '{2}' has no default name.",
                                        attrs[0].Type.Name, type.Assembly.Location, type.FullName);
                }
                else if (defaults.Count != 1)
                {
                    errors.AppendLine();
                    errors.AppendFormat("{0} declared in assembly '{1}' class '{2}' has multiple defaults: '{3}'",
                                        attrs[0].Type.Name, type.Assembly.Location, type.FullName, string.Join("', '", defaults));
                }

                // Verify #2 (ensure there is a description)
                //var desc = type.GetAttributes<DescriptionAttribute>(null).FirstOrDefault();
                //if (desc == null)
                //{
                //    errors.AppendLine();
                //    errors.AppendFormat("{0} declared in assembly '{1}' class '{2}' has no description.",
                //        attrs[0].Type.Name, type.Assembly.Location, type.FullName);
                //}

                // Verify #3 (all the parameters must be unique in name)
                var paramAttrs = type.GetAttributes <ParameterAttribute>(null).Select(a => a.name).ToList();
                var dupes      = paramAttrs.GroupBy(a => a).SelectMany(g => g.Skip(1)).Distinct().ToList();
                if (dupes.Count != 0)
                {
                    errors.AppendLine();
                    errors.AppendFormat("{0} declared in assembly '{1}' class '{2}' has duplicate parameters: '{3}'",
                                        attrs[0].Type.Name, type.Assembly.Location, type.FullName, string.Join("', '", dupes));
                }
            }

            string msg = errors.ToString();

            if (!string.IsNullOrEmpty(msg))
            {
                logger.Debug(msg);
                Assert.Null(msg);
            }
        }