private void AppendNode(SelectionRuleNode ruleNode, Node parent) { if (ruleNode != null) { Node node = RuleEditorHelper.CreateNode(ruleNode, _model); if (parent != null) { parent.Nodes.Add(node); } else { _decisionTree.Nodes.Add(node); _decisionTree.DisplayRootNode = node; } if (ruleNode is NaryRuleNode nary) { if (nary.Children.Count > 0) { foreach (SelectionRuleNode item in nary.Children) { AppendNode(item, node); } } } else if (ruleNode is UnaryRuleNode unary && unary.Child != null) { AppendNode(unary.Child, node); } } }
public override SelectionRuleNode CreateNode([NotNull] Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length >= 4 && parameters[0] is PropertyTypeItemContextType contextType && parameters[1] is string schemaNs && parameters[2] is string schemaName) { switch (contextType) { case PropertyTypeItemContextType.Boolean: if (parameters[3] is bool boolValue) { result = new BooleanRuleNode(node.Text, schemaNs, schemaName, boolValue) { Scope = Scope } } ; break; case PropertyTypeItemContextType.Comparison: if (parameters[3] is ComparisonOperator op && parameters[4] is string textValue) { result = new ComparisonRuleNode(node.Text, schemaNs, schemaName, op, textValue) { Scope = Scope } } ; break; case PropertyTypeItemContextType.EnumValue: if (parameters[3] is IEnumerable <string> values && parameters[4] is string value) { result = new EnumValueRuleNode(node.Text, schemaNs, schemaName, values, value) { Scope = Scope } } ; break; } } return(result); } }
public override SelectionRuleNode CreateNode(Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 1 && parameters[0] is bool boolValue) { result = new BooleanRuleNode(node.Text, null, null, boolValue) { Scope = Scope }; } return(result); }
public override SelectionRuleNode CreateNode([NotNull] Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 1 && parameters[0] is bool boolValue) { result = new CrossTrustBoundaryRuleNode(node.Text, boolValue) { Scope = Scope }; } return(result); }
public override SelectionRuleNode CreateNode(Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 2 && parameters[0] is ComparisonOperator op && parameters[1] is string value) { result = new ComparisonRuleNode(node.Text, null, null, op, value) { Scope = Scope }; } return(result); }
public override SelectionRuleNode CreateNode(Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 2 && parameters[0] is IEnumerable <string> values && parameters[1] is string value) { result = new EnumValueRuleNode(node.Text, null, null, values, value) { Scope = Scope }; } return(result); }
private void CreateGenerationRule([NotNull] ThreatModel model, [NotNull] ThreatType source, [NotNull] IThreatType target) { SelectionRuleNode include = AnalyzeGenerationRule(model, target.Model, source.IncludeFilter); SelectionRuleNode exclude = AnalyzeGenerationRule(model, target.Model, source.ExcludeFilter); SelectionRule rule = null; var andNode = new AndRuleNode() { Name = "AND" }; if (include != null) { andNode.Children.Add(include); } if (exclude != null) { andNode.Children.Add(new NotRuleNode() { Name = "NOT", Child = exclude }); } if (andNode.Children.Any()) { andNode.Children.Add(new BooleanRuleNode("Out of Scope", Resources.DefaultNamespace, Resources.TmtFlowPropertySchema, false) { Scope = AutoThreatGeneration.Engine.Scope.Object }); rule = new SelectionRule() { Root = andNode }; var schemaManager = new AutoThreatGenPropertySchemaManager(target.Model); var propertyType = schemaManager.GetPropertyType(); var property = target.GetProperty(propertyType) ?? target.AddProperty(propertyType, null); if (property is IPropertyJsonSerializableObject jsonSerializableObject) { jsonSerializableObject.Value = rule; } } }
public override SelectionRuleNode CreateNode([NotNull] Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 1 && parameters[0] is string entityTemplateName) { var entityTemplate = _model?.EntityTemplates?.Where(x => x.EntityType == EntityType.DataStore) .FirstOrDefault(x => string.CompareOrdinal(x.Name, entityTemplateName) == 0); if (entityTemplate != null) { result = new DataStoreTemplateRuleNode(entityTemplate) { Scope = Scope }; } } return(result); }
public override SelectionRuleNode CreateNode([NotNull] Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 1 && parameters[0] is string flowTemplateName) { var flowTemplate = _model?.FlowTemplates? .FirstOrDefault(x => string.CompareOrdinal(x.Name, flowTemplateName) == 0); if (flowTemplate != null) { result = new FlowTemplateRuleNode(flowTemplate) { Scope = Scope }; } } return(result); }
private SelectionRuleNode AnalyzeGenerationRule(ThreatModel source, IThreatModel target, string ruleText) { SelectionRuleNode result = null; if (!string.IsNullOrWhiteSpace(ruleText)) { ICharStream stream = CharStreams.fromstring(ruleText); ITokenSource lexer = new TmtLexer(stream, TextWriter.Null, TextWriter.Null); ITokenStream tokens = new CommonTokenStream(lexer); TmtParser parser = new TmtParser(tokens) { BuildParseTree = true }; IParseTree tree = parser.parse(); RuleVisitor visitor = new RuleVisitor(source, target); visitor.Visit(tree); result = visitor.Rule; } return(result); }
public override SelectionRuleNode CreateNode([NotNull] Node node, params object[] parameters) { SelectionRuleNode result = null; if (parameters != null && parameters.Length == 1 && parameters[0] is string entityTypeString) { var entityType = entityTypeString.GetEnumValue <EntityType>(); result = Incoming ? (SelectionRuleNode) new HasIncomingRuleNode(entityType) { Scope = Scope } : new HasOutgoingRuleNode(entityType) { Scope = Scope }; } return(result); }
public static void TraverseTree(Node currentNode, [NotNull] SelectionRule rule, SelectionRuleNode parentRuleNode) { SelectionRuleNode ruleNode = null; if (currentNode != null) { ruleNode = CreateRuleNode(currentNode); } if (parentRuleNode == null) { rule.Root = ruleNode; } else { if (parentRuleNode is NaryRuleNode nary) { if (ruleNode != null) { nary.Children.Add(ruleNode); } } else { if (parentRuleNode is UnaryRuleNode unary) { unary.Child = ruleNode; } } } if (currentNode?.HasChildNodes ?? false) { foreach (Node child in currentNode.Nodes) { TraverseTree(child, rule, ruleNode); } } }
private static SelectionRuleNode CreateRuleNode(Node node) { SelectionRuleNode result = null; if (node != null) { var schemaNs = node.GetSchemaNamespace(); var schema = node.GetSchemaName(); var switchButton = node.GetSwitchButton(); //var comboBox = node.GetComboBox(); var textValue = node.GetValue(); var values = node.GetComboBoxValues(); var value = node.GetComboBoxValue(); ComparisonOperator?comparisonOperator = node.GetComparisonOperator(); if (node.Tag is BooleanItemContext booleanItemContext) { if (switchButton != null) { result = booleanItemContext.CreateNode(node, switchButton.Value); } } else if (node.Tag is ComparisonItemContext comparisonItemContext) { if (comparisonOperator.HasValue) { result = comparisonItemContext.CreateNode(node, comparisonOperator.Value, textValue); } } else if (node.Tag is CrossTrustBoundaryItemContext crossTrustBoundaryItemContext) { if (switchButton != null) { result = crossTrustBoundaryItemContext.CreateNode(node, switchButton.Value); } } else if (node.Tag is EnumValueItemContext enumValueItemContext) { result = enumValueItemContext.CreateNode(node, values, value); } else if (node.Tag is FlowsItemContext flowsItemContext) { result = flowsItemContext.CreateNode(node, value); } else if (node.Tag is PropertyTypeItemContext propertyTypeItemContext) { switch (propertyTypeItemContext.ContextType) { case PropertyTypeItemContextType.Boolean: if (switchButton != null) { result = propertyTypeItemContext.CreateNode(node, propertyTypeItemContext.ContextType, schemaNs, schema, switchButton.Value); } break; case PropertyTypeItemContextType.Comparison: if (comparisonOperator.HasValue) { result = propertyTypeItemContext.CreateNode(node, propertyTypeItemContext.ContextType, schemaNs, schema, comparisonOperator.Value, textValue); } break; case PropertyTypeItemContextType.EnumValue: result = propertyTypeItemContext.CreateNode(node, propertyTypeItemContext.ContextType, schemaNs, schema, values, value); break; } } else if (node.Tag is ExternalInteractorTemplateItemContext externalInteractorTemplateItemContext) { result = externalInteractorTemplateItemContext.CreateNode(node, value); } else if (node.Tag is ProcessTemplateItemContext processTemplateItemContext) { result = processTemplateItemContext.CreateNode(node, value); } else if (node.Tag is DataStoreTemplateItemContext dataStoreTemplateItemContext) { result = dataStoreTemplateItemContext.CreateNode(node, value); } else if (node.Tag is TrustBoundaryTemplateItemContext trustBoundaryTemplateItemContext) { result = trustBoundaryTemplateItemContext.CreateNode(node, value); } else if (node.Tag is ButtonItemContext context) { result = context.CreateNode(node); } } return(result); }
public static Node CreateNode([NotNull] SelectionRuleNode ruleNode, [NotNull] IThreatModel model) { var result = new Node(ruleNode.Name) { Image = GetImage(ruleNode.Scope), }; if (ruleNode is NaryRuleNode nary) { if (nary is AndRuleNode) { result.Image = Resources.logic_and; } else if (nary is OrRuleNode) { result.Image = Resources.logic_or; } result.Tag = new NaryItemContext(ruleNode.GetType()); } else if (ruleNode is UnaryRuleNode unary) { if (unary is NotRuleNode) { result.Image = Resources.logic_not; } result.Tag = new NaryItemContext(ruleNode.GetType()); } else if (ruleNode is CrossTrustBoundaryRuleNode crossRuleNode) { UpdateNode(result, crossRuleNode); result.Tag = new CrossTrustBoundaryItemContext(); } else if (ruleNode is ComparisonRuleNode comparisonRuleNode) { UpdateNode(result, comparisonRuleNode); var propertyType = GetPropertyType(comparisonRuleNode.Namespace, comparisonRuleNode.Schema, comparisonRuleNode.Name, model); if (propertyType == null) { result.Tag = new ComparisonItemContext(comparisonRuleNode.Scope); } else { result.Tag = new PropertyTypeItemContext(propertyType, comparisonRuleNode.Scope, PropertyTypeItemContextType.Comparison); } } else if (ruleNode is EnumValueRuleNode enumValueRuleNode) { UpdateNode(result, enumValueRuleNode); var propertyType = GetPropertyType(enumValueRuleNode.Namespace, enumValueRuleNode.Schema, enumValueRuleNode.Name, model); if (propertyType == null) { result.Tag = new EnumValueItemContext(enumValueRuleNode.Values, enumValueRuleNode.Scope); } else { result.Tag = new PropertyTypeItemContext(propertyType, enumValueRuleNode.Scope, PropertyTypeItemContextType.EnumValue); } } else if (ruleNode is BooleanRuleNode booleanRuleNode) { UpdateNode(result, booleanRuleNode); var propertyType = GetPropertyType(booleanRuleNode.Namespace, booleanRuleNode.Schema, booleanRuleNode.Name, model); if (propertyType == null) { result.Tag = new BooleanItemContext(booleanRuleNode.Scope); } else { result.Tag = new PropertyTypeItemContext(propertyType, booleanRuleNode.Scope, PropertyTypeItemContextType.Boolean); } } else if (ruleNode is HasIncomingRuleNode hasIncomingRuleNode) { var flowsItemContext = new FlowsItemContext(true, hasIncomingRuleNode.Scope); UpdateNode(result, flowsItemContext.Values, hasIncomingRuleNode); result.Tag = flowsItemContext; } else if (ruleNode is HasOutgoingRuleNode hasOutgoingRuleNode) { var flowsItemContext = new FlowsItemContext(false, hasOutgoingRuleNode.Scope); UpdateNode(result, flowsItemContext.Values, hasOutgoingRuleNode); result.Tag = flowsItemContext; } else if (ruleNode is TruismRuleNode) { result.Image = Resources.ok; result.Tag = new TruismItemContext(); } else if (ruleNode is ExternalInteractorTemplateRuleNode externalInteractorTemplateRuleNode) { var externalInteractorTemplateItemContext = new ExternalInteractorTemplateItemContext(model, externalInteractorTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.ExternalInteractor), externalInteractorTemplateRuleNode); result.Tag = externalInteractorTemplateItemContext; } else if (ruleNode is ProcessTemplateRuleNode processTemplateRuleNode) { var processTemplateContext = new ProcessTemplateItemContext(model, processTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.Process), processTemplateRuleNode); result.Tag = processTemplateContext; } else if (ruleNode is DataStoreTemplateRuleNode dataStoreTemplateRuleNode) { var dataStoreTemplateItemContext = new DataStoreTemplateItemContext(model, dataStoreTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.DataStore), dataStoreTemplateRuleNode); result.Tag = dataStoreTemplateItemContext; } else if (ruleNode is EntityTemplateRuleNode entityTemplateRuleNode) { var entityTemplate = model.GetEntityTemplate(entityTemplateRuleNode.EntityTemplate); switch (entityTemplate.EntityType) { case EntityType.ExternalInteractor: var eiTemplateItemContext = new ExternalInteractorTemplateItemContext(model, entityTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.ExternalInteractor), entityTemplateRuleNode); result.Tag = eiTemplateItemContext; break; case EntityType.Process: var pTemplateContext = new ProcessTemplateItemContext(model, entityTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.Process), entityTemplateRuleNode); result.Tag = pTemplateContext; break; case EntityType.DataStore: var dsTemplateItemContext = new DataStoreTemplateItemContext(model, entityTemplateRuleNode.Scope); UpdateNode(result, model.EntityTemplates?.Where(x => x.EntityType == EntityType.DataStore), entityTemplateRuleNode); result.Tag = dsTemplateItemContext; break; default: throw new ArgumentOutOfRangeException(); } } else if (ruleNode is TrustBoundaryTemplateRuleNode trustBoundaryTemplateRuleNode) { var trustBoundaryContext = new TrustBoundaryTemplateItemContext(model, trustBoundaryTemplateRuleNode.Scope); UpdateNode(result, model.TrustBoundaryTemplates, trustBoundaryTemplateRuleNode); result.Tag = trustBoundaryContext; } else if (ruleNode is FlowTemplateRuleNode flowTemplateRuleNode) { var flowTemplateContext = new FlowTemplateItemContext(model, flowTemplateRuleNode.Scope); UpdateNode(result, model.FlowTemplates, flowTemplateRuleNode); result.Tag = flowTemplateContext; } return(result); }