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