analysis: if relation defined, define trustlevel

lang-example/mc.cfg

 /**
- * Generated on Tue Oct 21 18:56:09 CEST 2014
+ * Generated on Wed Oct 22 04:37:32 CEST 2014
  */
 config {
     Require-Model:

montiSecArcAnalysis/mc.cfg

 /**
- * Generated on Tue Oct 21 18:56:29 CEST 2014
+ * Generated on Wed Oct 22 04:37:51 CEST 2014
  */
 config {
     Require-Model:

montiSecArcAnalysis/src/main/java/secarc/error/MontiSecArcAnalysisErrorCodes.java

@@ -141,4 +141,8 @@ public enum MontiSecArcAnalysisErrorCodes implements IErrorCode {
 	 */
 	FilterWithHigherTrust,
 	
+	/**
+	 * For a trustlevel relation should exist trustlevels
+	 */
+	TrustlevelForTrustlevelrelation,
 }

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/checker/ISecAnalysisConnectorChecker.java

@@ -3,6 +3,7 @@ package secarc.ets.analysis.checker;
 import mc.umlp.arcd._ast.ASTArcConnector;
 import mc.umlp.arcd._ast.ASTArcSimpleConnector;
 import secarc.ets.entries.SecConnectorEntry;
+import secarc.ets.graph.ArchitectureGraph;
 import interfaces2.resolvers.AmbigousException;
 
 /**
@@ -26,7 +27,7 @@ public interface ISecAnalysisConnectorChecker {
 	 * @param entry
 	 * @throws AmbigousException
 	 */
-	void check(ASTArcConnector node, SecConnectorEntry entry) throws AmbigousException;
+	void check(ASTArcConnector node, SecConnectorEntry entry, ArchitectureGraph graph) throws AmbigousException;
 	
 	/**
 	 * 
@@ -34,6 +35,6 @@ public interface ISecAnalysisConnectorChecker {
 	 * @param entry entry related connector entry to be checked
 	 * @throws AmbigousException 
 	 */
-	void check(ASTArcSimpleConnector node, SecConnectorEntry entry) throws AmbigousException;
+	void check(ASTArcSimpleConnector node, SecConnectorEntry entry, ArchitectureGraph graph) throws AmbigousException;
 	
 }

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/checker/ISecAnalysisTrustlevelRelationChecker.java

+package secarc.ets.analysis.checker;
+
+import interfaces2.resolvers.AmbigousException;
+import secarc._ast.ASTSecArcTrustlevelRelation;
+import secarc.ets.entries.TrustlevelRelationEntry;
+
+/**
+ * Analysis checker interface for checking trustlevelrelation
+ * related analysis
+ * 
+ * <br>
+ * <br>
+ * Copyright (c) 2011 RWTH Aachen. All rights reserved
+ * 
+ * @author (last commit) $Author$
+ * @version $Date$<br>
+ * $Revision$
+ * 
+ */
+public interface ISecAnalysisTrustlevelRelationChecker {
+
+	/**
+	 * 
+	 * @param node
+	 * @param entry
+	 * @param graph
+	 * @throws AmbigousException
+	 */
+	void check(ASTSecArcTrustlevelRelation node, TrustlevelRelationEntry entry) throws AmbigousException;
+	
+}

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/connect/UnencryptedConnectorThroughLowTurstlevel.java

@@ -16,6 +16,7 @@ import secarc.ets.check.MontiSecArcAnalysisConstants;
 import secarc.ets.entries.SecComponentEntry;
 import secarc.ets.entries.SecConnectorEntry;
 import secarc.ets.entries.SecSubComponentEntry;
+import secarc.ets.graph.ArchitectureGraph;
 
 /**
  * Checks if an unencrypted connector is embedded in a component with a low trustlevel
@@ -43,7 +44,7 @@ public class UnencryptedConnectorThroughLowTurstlevel extends Analysis
 	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(cc.clarc.lang.architecture._ast.ASTArcConnector, secarc.ets.entries.SecConnectorEntry)
 	 */
 	@Override
-	public void check(ASTArcConnector node, SecConnectorEntry entry)
+	public void check(ASTArcConnector node, SecConnectorEntry entry, ArchitectureGraph graph)
 			throws AmbigousException {
 		innerCheck(node, entry, node.getMainParent());
 	}
@@ -53,7 +54,7 @@ public class UnencryptedConnectorThroughLowTurstlevel extends Analysis
 	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(mc.umlp.arcd._ast.ASTArcSimpleConnector, secarc.ets.entries.SecConnectorEntry)
 	 */
 	@Override
-	public void check(ASTArcSimpleConnector node, SecConnectorEntry entry)
+	public void check(ASTArcSimpleConnector node, SecConnectorEntry entry, ArchitectureGraph graph)
 			throws AmbigousException {
 		innerCheck(node, entry, node.getMainParent());
 	}
@@ -77,7 +78,7 @@ public class UnencryptedConnectorThroughLowTurstlevel extends Analysis
 		//Find source component
 		if(sourceRef.contains(".")) {
 			String nameSourceComp = sourceRef.substring(0, sourceRef.indexOf(".")); 
-			sourceSubComp = (SecSubComponentEntry) resolver.resolve(nameSourceComp, SubComponentEntry.KIND, getNameSpaceFor(nodeParent.getMainParent()));
+			sourceSubComp = (SecSubComponentEntry) resolver.resolve(nameSourceComp, SubComponentEntry.KIND, getNameSpaceFor(nodeParent));
 			//Check in a coco
 			if(sourceSubComp != null) {
 				sourceComp = (SecComponentEntry) sourceSubComp.getComponentType().getBestKnownVersion();
@@ -93,7 +94,7 @@ public class UnencryptedConnectorThroughLowTurstlevel extends Analysis
 		//Find traget component
 		if(targetRef.contains(".")) {
 			String nameTargetComp = targetRef.substring(0, targetRef.indexOf("."));
-			targetSubComp = (SecSubComponentEntry) resolver.resolve(nameTargetComp, SubComponentEntry.KIND, getNameSpaceFor(nodeParent.getMainParent()));
+			targetSubComp = (SecSubComponentEntry) resolver.resolve(nameTargetComp, SubComponentEntry.KIND, getNameSpaceFor(nodeParent));
 			//Check in a coco
 			if(targetSubComp != null) {
 				targetComp = (SecComponentEntry) targetSubComp.getComponentType().getBestKnownVersion();

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/filter/FilterWithHigherTrustlevel.java

@@ -8,7 +8,6 @@ import mc.umlp.arcd._ast.ASTArcComponent;
 import mc.umlp.arcd._ast.ASTArcPort;
 import mc.umlp.arcd.ets.entries.ComponentEntry;
 import secarc._ast.ASTSecArcFilter;
-import secarc._ast.ASTSecArcFilterComponent;
 import secarc.error.MontiSecArcAnalysisErrorCodes;
 import secarc.ets.analysis.checker.Analysis;
 import secarc.ets.analysis.checker.ISecAnalysisFilterChecker;

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/filter/TaintTracking.java

@@ -4,19 +4,28 @@ package secarc.ets.analysis.filter;
 import org.jgrapht.traverse.DepthFirstIterator;
 import org.jgrapht.traverse.GraphIterator;
 
-import secarc._ast.ASTSecArcFilter;
 import secarc.error.MontiSecArcAnalysisErrorCodes;
 import secarc.ets.analysis.checker.Analysis;
-import secarc.ets.analysis.checker.ISecAnalysisFilterChecker;
+import secarc.ets.analysis.checker.ISecAnalysisConnectorChecker;
+import secarc.ets.check.CoCoHelper;
 import secarc.ets.check.MontiSecArcAnalysisConstants;
 import secarc.ets.entries.FilterEntry;
+import secarc.ets.entries.SecComponentEntry;
+import secarc.ets.entries.SecConnectorEntry;
+import secarc.ets.entries.SecSubComponentEntry;
 import secarc.ets.graph.ArchitectureGraph;
 import secarc.ets.graph.Edge;
 import secarc.ets.graph.Vertex;
 import interfaces2.STEntry;
 import interfaces2.resolvers.AmbigousException;
 import mc.IErrorCode;
+import mc.ast.ASTNode;
+import mc.umlp.arcd._ast.ASTArcComponent;
+import mc.umlp.arcd._ast.ASTArcConnector;
+import mc.umlp.arcd._ast.ASTArcSimpleConnector;
+import mc.umlp.arcd.ets.entries.ComponentEntry;
 import mc.umlp.arcd.ets.entries.ConnectorEntry;
+import mc.umlp.arcd.ets.entries.SubComponentEntry;
 
 /**
  * Checks the path to the filter
@@ -30,48 +39,158 @@ import mc.umlp.arcd.ets.entries.ConnectorEntry;
  * $Revision$
  * 
  */
-public class TaintTracking extends Analysis implements ISecAnalysisFilterChecker {
+public class TaintTracking extends Analysis implements ISecAnalysisConnectorChecker {
 
 	public TaintTracking() {
 		super(MontiSecArcAnalysisConstants.TAINT_TRACKING);
 	}
+	
+	/*
+	 * (non-Javadoc)
+	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(mc.umlp.arcd._ast.ASTArcConnector, secarc.ets.entries.SecConnectorEntry)
+	 */
+	@Override
+	public void check(ASTArcConnector node, SecConnectorEntry entry, ArchitectureGraph graph)
+			throws AmbigousException {
+		innerCheck(node, node.getMainParent(), entry, graph);
+	}
 
 	/*
 	 * (non-Javadoc)
-	 * @see secarc.ets.analysis.checker.ISecAnalysisFilterChecker#check(secarc._ast.ASTSecArcFilter, secarc.ets.entries.FilterEntry)
+	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(mc.umlp.arcd._ast.ASTArcSimpleConnector, secarc.ets.entries.SecConnectorEntry)
 	 */
 	@Override
-	public void check(ASTSecArcFilter node, FilterEntry entry, ArchitectureGraph graph)
+	public void check(ASTArcSimpleConnector node, SecConnectorEntry entry, ArchitectureGraph graph)
 			throws AmbigousException {
+		innerCheck(node, node.getMainParent(), entry, graph);
+	}
+	
+	protected void innerCheck(ASTNode node, ASTArcComponent nodeParent, SecConnectorEntry entry, ArchitectureGraph graph) throws AmbigousException {
+		
+		if(checkForTrustlevelRelation(nodeParent, entry)) {
+			return;
+		}
 		
-		Vertex<FilterEntry> filterVertex = Vertex.of(entry);
+		//Start check for filtering
+		Vertex<ConnectorEntry> connectorVertex = Vertex.of(entry);
 		
 		//Look for paths with port as beginning
-		GraphIterator<Vertex<? extends STEntry>, Edge> iterator = new DepthFirstIterator<Vertex<? extends STEntry>, Edge>(graph.getReversedRawGraph(), filterVertex);
+		GraphIterator<Vertex<? extends STEntry>, Edge> iterator = new DepthFirstIterator<Vertex<? extends STEntry>, Edge>(graph.getRawGraph(), connectorVertex);
 		
 		STEntry element = null;
+			
+		StringBuilder sBuilder = new StringBuilder("Taint tracking: The trustlevel becomes lower with this transition " + entry + ". Before the input is used, it must be filtered. The following pass is used: " + entry);
 		
-		StringBuilder sBuilder = new StringBuilder("Taint tracking: The filter " + entry.getName() + " has the following paths: " + iterator.next().getArchitectureElement().getName());
+		//Already used
+		iterator.next();
 		
 		while(iterator.hasNext()) {
 			element = iterator.next().getArchitectureElement();
 			
 			if(element.equals(entry)) {
-				sBuilder.append(", ");
-			} else {
-				sBuilder.append(" -> ");
+				sBuilder.append(", " + entry);
 			}
 			
 			if(element instanceof ConnectorEntry) {
-				sBuilder.append(element);
-			} else {
-				sBuilder.append(element.getName());
+				sBuilder.append(" -> " + element);
+			} 
+			
+			if(element instanceof FilterEntry) {
+				sBuilder.append(element.getName() + "*");
 			}
 			
 		}
 		
+		sBuilder.append(" The filter is marked with a *.");
+		
 		addReport(sBuilder.toString(), node.get_SourcePositionStart());
+	}
+	
+	private boolean checkForTrustlevelRelation(ASTArcComponent nodeParent, SecConnectorEntry entry) throws AmbigousException {
 		
+		SecComponentEntry parentComp = (SecComponentEntry) resolver.resolve(nodeParent.getName(), ComponentEntry.KIND, getNameSpaceFor(nodeParent));
+		
+		// Component source
+		String sourceRef = entry.getSource();
+		SecSubComponentEntry sourceSubComp = null;
+		SecComponentEntry sourceComp = null;
+		// Find source component
+		if (sourceRef.contains(".")) {
+			String nameSourceComp = sourceRef.substring(0, sourceRef.indexOf("."));
+			sourceSubComp = (SecSubComponentEntry) resolver.resolve(nameSourceComp, SubComponentEntry.KIND, getNameSpaceFor(nodeParent));
+			// Check in a coco
+			if (sourceSubComp != null) {
+				sourceComp = (SecComponentEntry) sourceSubComp.getComponentType().getBestKnownVersion();
+			}
+		} else {
+			sourceComp = parentComp;
+		}
+
+		// Component target
+		String targetRef = entry.getTarget();
+		SecSubComponentEntry targetSubComp = null;
+		SecComponentEntry targetComp = null;
+		// Find traget component
+		if (targetRef.contains(".")) {
+			String nameTargetComp = targetRef.substring(0, targetRef.indexOf("."));
+			targetSubComp = (SecSubComponentEntry) resolver.resolve(nameTargetComp, SubComponentEntry.KIND,
+					getNameSpaceFor(nodeParent));
+			// Check in a coco
+			if (targetSubComp != null) {
+				targetComp = (SecComponentEntry) targetSubComp.getComponentType().getBestKnownVersion();
+			}
+		} else {
+			targetComp = parentComp;
+		}
+		
+		int targetTrustlevel = -1;
+		int sourceTrustlevel = -1;
+		
+		if(sourceComp.getTrustlevel().isPresent()) {
+			sourceTrustlevel = CoCoHelper.getTrustlevelAsInteger(sourceComp);
+		} else {
+			SecComponentEntry parentTurstlevelSource = getTrustlevel((ASTArcComponent) sourceComp.getBestKnownVersion().getNode());
+			if(parentTurstlevelSource != null) {
+				sourceTrustlevel = CoCoHelper.getTrustlevelAsInteger(parentTurstlevelSource);
+			}
+		}
+		
+		if(targetComp.getTrustlevel().isPresent()) {
+			targetTrustlevel = CoCoHelper.getTrustlevelAsInteger(targetComp);
+		} else {
+			SecComponentEntry parentTurstlevelTarget = getTrustlevel((ASTArcComponent) targetComp.getBestKnownVersion().getNode());
+			if(parentTurstlevelTarget != null) {
+				targetTrustlevel = CoCoHelper.getTrustlevelAsInteger(parentTurstlevelTarget);
+			}
+		}
+		
+		//If the trustlevel is the lower, the input do not need to be checked again
+		//if the trustlevel ist the same, then check it for the transition before
+		if(sourceTrustlevel > targetTrustlevel) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+	
+	/**
+	 * Search for trustlevel in super components 
+	 * @param node
+	 * @return trustlevel
+	 * @throws AmbigousException
+	 */
+	private SecComponentEntry getTrustlevel(ASTArcComponent node) throws AmbigousException {
+		ASTArcComponent parent = node.getMainParent();
+		if(parent != null) {
+			SecComponentEntry componentParent = (SecComponentEntry) resolver.resolve(parent.getName(), ComponentEntry.KIND, getNameSpaceFor(parent));
+			if(componentParent.getTrustlevel().isPresent()) {
+				return componentParent;
+			} else {
+				return getTrustlevel(parent);
+			}
+		} else {
+			return null;
+		}
 	}
 	
 	/*

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/filter/TrustlevelPathHigherThanEnvironment.java

@@ -13,6 +13,7 @@ import secarc.ets.analysis.checker.ISecAnalysisConnectorChecker;
 import secarc.ets.check.MontiSecArcAnalysisConstants;
 import secarc.ets.entries.SecComponentEntry;
 import secarc.ets.entries.SecConnectorEntry;
+import secarc.ets.graph.ArchitectureGraph;
 
 /**
  * Checks if the trustlevel of the encrypted path is higher than the environment
@@ -40,7 +41,7 @@ public class TrustlevelPathHigherThanEnvironment extends Analysis implements
 	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(mc.umlp.arcd._ast.ASTArcConnector, secarc.ets.entries.SecConnectorEntry)
 	 */
 	@Override
-	public void check(ASTArcConnector node, SecConnectorEntry entry) throws AmbigousException {
+	public void check(ASTArcConnector node, SecConnectorEntry entry, ArchitectureGraph graph) throws AmbigousException {
 		innerCheck(node, entry, node.getMainParent());
 	}
 	
@@ -49,7 +50,7 @@ public class TrustlevelPathHigherThanEnvironment extends Analysis implements
 	 * @see secarc.ets.analysis.checker.ISecAnalysisConnectorChecker#check(mc.umlp.arcd._ast.ASTArcSimpleConnector, secarc.ets.entries.SecConnectorEntry)
 	 */
 	@Override
-	public void check(ASTArcSimpleConnector node, SecConnectorEntry entry)
+	public void check(ASTArcSimpleConnector node, SecConnectorEntry entry, ArchitectureGraph graph)
 			throws AmbigousException {
 		innerCheck(node, entry, node.getMainParent());
 	}

montiSecArcAnalysis/src/main/java/secarc/ets/analysis/trustlevelrelation/TrustlevelForTrustlevelRelation.java

+package secarc.ets.analysis.trustlevelrelation;
+
+import interfaces2.resolvers.AmbigousException;
+import mc.IErrorCode;
+import mc.umlp.arcd.ets.entries.SubComponentEntry;
+import secarc._ast.ASTSecArcIdentity;
+import secarc._ast.ASTSecArcTrustlevelRelation;
+import secarc.error.MontiSecArcAnalysisErrorCodes;
+import secarc.ets.check.MontiSecArcAnalysisConstants;
+import secarc.ets.cocos.common.ComponentExistence;
+import secarc.ets.entries.IdentityEntry;
+import secarc.ets.entries.SecComponentEntry;
+import secarc.ets.entries.TrustlevelRelationEntry;
+
+public class TrustlevelForTrustlevelRelation extends ComponentExistence {
+
+	public TrustlevelForTrustlevelRelation() {
+		super(MontiSecArcAnalysisConstants.TRUSTLEVEL_FOR_TRUSTLEVELRELATION);
+	}
+	
+	@Override
+	public void check(ASTSecArcIdentity node, IdentityEntry entry)
+			throws AmbigousException {
+		
+	}
+
+	@Override
+	public void check(ASTSecArcTrustlevelRelation node,
+			TrustlevelRelationEntry entry) throws AmbigousException {
+		
+		String refLowerTrustlevelComponent = entry.getComponentWithLowerTrustlevel();
+		String refHigherTrustlevelComponent = entry.getComponentWithHigherTrustlevel();
+		
+		SubComponentEntry lowerTrustlevelComoponent = innerCheck(node, node.getMainParent(), refLowerTrustlevelComponent);
+		
+		SubComponentEntry higherTrustlevelComoponent = innerCheck(node, node.getMainParent(), refHigherTrustlevelComponent);
+		
+		//Checked in coco
+		if(lowerTrustlevelComoponent == null || higherTrustlevelComoponent == null) {
+			return;
+		}
+		
+		if(!((SecComponentEntry) lowerTrustlevelComoponent.getComponentType()).getTrustlevel().isPresent() || !((SecComponentEntry) higherTrustlevelComoponent.getComponentType()).getTrustlevel().isPresent()) {
+			addReport("If a trustlevel relation is defined between the components " + lowerTrustlevelComoponent.getName() + " and " + higherTrustlevelComoponent.getName() + ", then trustlevel should be defined for both.", node.get_SourcePositionStart());			
+		}
+		
+	}
+
+	@Override
+	public IErrorCode getErrorCode() {
+		return MontiSecArcAnalysisErrorCodes.TrustlevelForTrustlevelrelation;
+	}
+
+}

montiSecArcAnalysis/src/main/java/secarc/ets/check/MontiSecArcAnalysisConstants.java

@@ -86,4 +86,8 @@ public final class MontiSecArcAnalysisConstants {
 	
 	public static final String LIST_THIRD_PARTY_COMPONENTS = "Lists all third party components of the system.";
 	
+	public static final String ALL_TRUSTLEVEL_RELATION = "Checks all analysis related to trustlevel relation.";
+	
+	public static final String TRUSTLEVEL_FOR_TRUSTLEVELRELATION = "Checks if a trustlevel exists for a trustlevel relation.";
+	
 }

montiSecArcAnalysis/src/main/java/secarc/ets/check/MontiSecArcAnalysisCreator.java

@@ -28,6 +28,7 @@ import secarc.ets.analysis.role.DerivedRolesThirdParty;
 import secarc.ets.analysis.role.RoleAccess;
 import secarc.ets.analysis.trustlevel.DerivedTrustlevel;
 import secarc.ets.analysis.trustlevel.ReasonForDifferingTrustlevel;
+import secarc.ets.analysis.trustlevelrelation.TrustlevelForTrustlevelRelation;
 
 
 import mc.ProblemReport;
@@ -195,6 +196,12 @@ public final class MontiSecArcAnalysisCreator {
 			//Lists all third party componnts
 			componentAnalysis.addChild(new ListThirdPartyComponents());
 			
+			//Analysis for trustlevel relation
+			CompositeContextCondition trustlevelRelationAnalysis = new CompositeContextCondition(MontiSecArcAnalysisConstants.ALL_TRUSTLEVEL_RELATION);
+			
+			//If a relation is defined, define trustlevel
+			trustlevelRelationAnalysis.addChild(new TrustlevelForTrustlevelRelation());
+			
 			analysis.addChild(connectorAnalysis);
 			analysis.addChild(filterAnalysis);
 			analysis.addChild(portAnalysis);
@@ -203,6 +210,7 @@ public final class MontiSecArcAnalysisCreator {
 			analysis.addChild(identityAnalysis);
 			analysis.addChild(trustlevelAnalysis);
 			analysis.addChild(componentAnalysis);
+			analysis.addChild(trustlevelRelationAnalysis);
 			
 		}
 		return analysis;

montiSecArcAnalysis/src/main/java/secarc/ets/check/MontiSecArcAnalysisVisitor.java

@@ -24,6 +24,7 @@ import secarc._ast.ASTSecArcConfiguration;
 import secarc._ast.ASTSecArcFilter;
 import secarc._ast.ASTSecArcIdentity;
 import secarc._ast.ASTSecArcRole;
+import secarc._ast.ASTSecArcTrustlevelRelation;
 import secarc.ets.analysis.checker.ISecAnalysisComponentChecker;
 import secarc.ets.analysis.checker.ISecAnalysisConfigurationChecker;
 import secarc.ets.analysis.checker.ISecAnalysisConnectorChecker;
@@ -31,6 +32,7 @@ import secarc.ets.analysis.checker.ISecAnalysisFilterChecker;
 import secarc.ets.analysis.checker.ISecAnalysisIdentityChecker;
 import secarc.ets.analysis.checker.ISecAnalysisPortChecker;
 import secarc.ets.analysis.checker.ISecAnalysisRoleChecker;
+import secarc.ets.cocos.checkers.ISecTrustlevelRelationChecker;
 import secarc.ets.entries.ConfigurationEntry;
 import secarc.ets.entries.FilterEntry;
 import secarc.ets.entries.IdentityEntry;
@@ -38,6 +40,7 @@ import secarc.ets.entries.RoleEntry;
 import secarc.ets.entries.SecComponentEntry;
 import secarc.ets.entries.SecConnectorEntry;
 import secarc.ets.entries.SecPortEntry;
+import secarc.ets.entries.TrustlevelRelationEntry;
 import secarc.ets.graph.ArchitectureGraph;
 import secarc.ets.graph.ArchitectureGraphBuilder;
 
@@ -95,6 +98,11 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
 	 */
 	private Set<ISecAnalysisRoleChecker> analysisRoleChecker;
 	
+	/**
+	 * Analysis for trustlevel relation
+	 */
+	private Set<ISecTrustlevelRelationChecker> analysisTrustlevelRelationChecker;
+	
 	
 	public MontiSecArcAnalysisVisitor() {
 		analysisFilterChecker = new HashSet<ISecAnalysisFilterChecker>();
@@ -104,6 +112,7 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
 		analysisComponentChecker = new HashSet<ISecAnalysisComponentChecker>();
 		analysisIdentityChecker = new HashSet<ISecAnalysisIdentityChecker>();
 		analysisRoleChecker = new HashSet<ISecAnalysisRoleChecker>();
+		analysisTrustlevelRelationChecker = new HashSet<ISecTrustlevelRelationChecker>();
 	}
 	
 	/**
@@ -143,6 +152,9 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
 			if(coco instanceof ISecAnalysisRoleChecker) {
 				analysisRoleChecker.add((ISecAnalysisRoleChecker) coco);
 			}
+			if(coco instanceof ISecTrustlevelRelationChecker) {
+				analysisTrustlevelRelationChecker.add((ISecTrustlevelRelationChecker) coco);
+			}
 		}
 	}
 	
@@ -232,7 +244,7 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
                         getNameSpaceFor(node.getMainParent()));
                 if (entry != null) {
                     for (ISecAnalysisConnectorChecker cc : analysisConnectorChecker) {
-                        cc.check(node, entry);
+                        cc.check(node, entry, graph);
                     }
                 }
             } catch (AmbigousException e) {
@@ -252,7 +264,7 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
                         getNameSpaceFor(node.getMainParent()));
                 if (entry != null) {
                     for (ISecAnalysisConnectorChecker cc : analysisConnectorChecker) {
-                        cc.check(node, entry);
+                        cc.check(node, entry, graph);
                     }
                 }
             } catch (AmbigousException e) {
@@ -318,4 +330,27 @@ public class MontiSecArcAnalysisVisitor extends CheckWorkflowClient {
         }
 	}
 	
+	/**
+	 * Visits trustlevel relation
+	 */
+	public void visit(ASTSecArcTrustlevelRelation node) {
+		try {
+			String name = "";
+			if(node.isGT()) {
+				name = NameHelper.dotSeparatedStringFromList(node.getClient().getParts());
+			} else {
+				name = NameHelper.dotSeparatedStringFromList(node.getServer().getParts());
+			}
+			TrustlevelRelationEntry entry = (TrustlevelRelationEntry) resolver.resolve(name, TrustlevelRelationEntry.KIND, getNameSpaceFor(node));
+			if(entry != null) {
+				for(ISecTrustlevelRelationChecker cc : analysisTrustlevelRelationChecker) {
+					cc.check(node, entry);
+				}
+			}
+		} catch (AmbigousException e) {
+			// not checked here
+            MCG.getLogger().info(e.getMessage());
+		}
+	}
+	
 }

montiSecArcAnalysis/src/test/java/secarc/MontiSecArcAnalysisTest.java

@@ -48,7 +48,7 @@ public class MontiSecArcAnalysisTest extends TestWithSymtabAnalysis<MontiSecArcA
 		errorCodes.add(MontiSecArcAnalysisErrorCodes.EncryptedPathEndInLowTrustlevel);
 		errorCodes.add(MontiSecArcAnalysisErrorCodes.ListThirdPartyComponents);
 
-        assertEquals(3, handler.getWarnings().size());
+        assertEquals(4, handler.getWarnings().size());
         for(ProblemReport error : handler.getErrors()) {
         	assertTrue(errorCodes.contains(error.getErrorcode()));
         }
@@ -123,7 +123,7 @@ public class MontiSecArcAnalysisTest extends TestWithSymtabAnalysis<MontiSecArcA
 	    tool.init();
 	    assertTrue(tool.run());
 		
-		assertEquals(2, handler.getWarnings().size());
+		assertEquals(1, handler.getWarnings().size());
         for(ProblemReport error : handler.getErrors()) {
         	a