-
Moemoea Fierin authoredMoemoea Fierin authored
SecurityGeneration.java 84.80 KiB
package ui;
import java.awt.Point;
import java.io.Reader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import avatartranslator.AvatarPragmaAuthenticity;
import avatartranslator.AvatarPragmaSecret;
import avatartranslator.AvatarSpecification;
import avatartranslator.toproverif.AVATAR2ProVerif;
import common.ConfigurationTTool;
import launcher.RshClient;
import myutil.TraceManager;
import proverifspec.ProVerifOutputAnalyzer;
import proverifspec.ProVerifQueryAuthResult;
import proverifspec.ProVerifQueryResult;
import proverifspec.ProVerifSpec;
import tmltranslator.TMLChannel;
import tmltranslator.TMLMapping;
import tmltranslator.TMLModeling;
import tmltranslator.TMLPort;
import tmltranslator.TMLTask;
import tmltranslator.toavatar.TML2Avatar;
import ui.tmlad.TGConnectorTMLAD;
import ui.tmlad.TMLADChoice;
import ui.tmlad.TMLADDecrypt;
import ui.tmlad.TMLADEncrypt;
import ui.tmlad.TMLADReadChannel;
import ui.tmlad.TMLADReadRequestArg;
import ui.tmlad.TMLADSendRequest;
import ui.tmlad.TMLADStartState;
import ui.tmlad.TMLADStopState;
import ui.tmlad.TMLADWriteChannel;
import ui.tmlad.TMLActivityDiagramPanel;
import ui.tmlcompd.TMLCChannelOutPort;
import ui.tmlcompd.TMLCCompositeComponent;
import ui.tmlcompd.TMLCPortConnector;
import ui.tmlcompd.TMLCPrimitiveComponent;
import ui.tmlcompd.TMLCPrimitivePort;
import ui.tmlcompd.TMLComponentTaskDiagramPanel;
import ui.tmldd.TMLArchiArtifact;
import ui.tmldd.TMLArchiBUSNode;
import ui.tmldd.TMLArchiCPUNode;
import ui.tmldd.TMLArchiConnectorNode;
import ui.tmldd.TMLArchiDiagramPanel;
import ui.tmldd.TMLArchiHWANode;
import ui.tmldd.TMLArchiMemoryNode;
public class SecurityGeneration implements Runnable {
MainGUI gui;
String name;
TMLMapping<TGComponent> map;
TMLArchiPanel newarch;
String encComp;
String overhead;
String decComp;
Map<String, List<String>> selectedCPUTasks;
boolean autoConf;
boolean autoWeakAuth;
boolean autoStrongAuth;
int channelIndex=0;
TMLComponentDesignPanel tmlcdp; AVATAR2ProVerif avatar2proverif;
AvatarSpecification avatarspec;
ProVerifSpec proverif;
Map<String, HSMChannel> hsmChannels = new HashMap<String, HSMChannel>();
Map<String, HSMChannel> secChannels = new HashMap<String, HSMChannel>();
Map<String, Integer> channelIndexMap = new HashMap<String, Integer>();
Map<String, List<HSMChannel>> hsmChannelMap = new HashMap<String, List<HSMChannel>>();
Map<String, String> taskHSMMap = new HashMap<String, String>();
List<String> hsmTasks = new ArrayList<String>();
Map<String, String> channelSecMap = new HashMap<String, String>();
TMLMapping<TGComponent> newMap;
public SecurityGeneration(MainGUI gui, String name, TMLMapping<TGComponent> map, TMLArchiPanel newarch, String encComp, String overhead, String decComp, boolean autoConf, boolean autoWeakAuth, boolean autoStrongAuth, Map<String, List<String>> selectedCPUTasks){
this.gui = gui;
this.name=name;
this.map=map;
this.newMap=map;
this.newarch=newarch;
this.encComp = encComp;
this.overhead = overhead;
this.decComp = decComp;
this.autoConf=autoConf;
this.autoWeakAuth = autoWeakAuth;
this.autoStrongAuth = autoStrongAuth;
this.selectedCPUTasks = selectedCPUTasks;
}
public void proverifAnalysis(TMLMapping<TGComponent> map, List<String> nonAuthChans, List<String> nonConfChans) {
if (map == null) {
TraceManager.addDev("No mapping");
return;
}
//Perform ProVerif Analysis
TML2Avatar t2a = new TML2Avatar(newMap, false, true);
AvatarSpecification avatarspec = t2a.generateAvatarSpec("1");
if (avatarspec == null) {
TraceManager.addDev("No avatar spec");
return;
}
avatar2proverif = new AVATAR2ProVerif(avatarspec);
try {
proverif = avatar2proverif.generateProVerif(true, true, 3, true, true);
//warnings = avatar2proverif.getWarnings();
if (!avatar2proverif.saveInFile("pvspec")) {
return;
}
RshClient rshc = new RshClient(ConfigurationTTool.ProVerifVerifierHost);
rshc.setCmd(ConfigurationTTool.ProVerifVerifierPath + " -in pitype pvspec");
rshc.sendExecuteCommandRequest();
Reader data = rshc.getDataReaderFromProcess();
ProVerifOutputAnalyzer pvoa = avatar2proverif.getOutputAnalyzer();
pvoa.analyzeOutput(data, true);
if (pvoa.getResults().size() ==0){
TraceManager.addDev("ERROR: No security results");
}
Map<AvatarPragmaSecret, ProVerifQueryResult> confResults = pvoa.getConfidentialityResults();
for (AvatarPragmaSecret pragma : confResults.keySet()) {
// System.out.println("Pragma " + pragma);
if (confResults.get(pragma).isProved() && !confResults.get(pragma).isSatisfied()) {
nonConfChans.add(pragma.getArg().getBlock().getName() + "__" + pragma.getArg().getName());
TraceManager.addDev(pragma.getArg().getBlock().getName() + "." + pragma.getArg().getName() + " is not secret");
TMLChannel chan = map.getTMLModeling().getChannelByShortName(pragma.getArg().getName().replaceAll("_chData", ""));
if (chan==null){
chan = map.getTMLModeling().getChannelByOriginPortName(pragma.getArg().getName().replaceAll("_chData", ""));
}
if (chan==null){
continue;
}
if (chan.isBasicChannel()){
nonConfChans.add(chan.getOriginTask().getName() + "__" + pragma.getArg().getName());
}
else {
for (TMLTask originTask: chan.getOriginTasks()){
nonConfChans.add(originTask.getName() + "__" + pragma.getArg().getName());
}
}
}
}
Map<AvatarPragmaAuthenticity, ProVerifQueryAuthResult> authResults = pvoa.getAuthenticityResults();
for (AvatarPragmaAuthenticity pragma : authResults.keySet()) {
if (authResults.get(pragma).isProved() && !authResults.get(pragma).isSatisfied()) {
nonAuthChans.add(pragma.getAttrA().getAttribute().getBlock().getName() + "__" + pragma.getAttrA().getAttribute().getName().replaceAll("_chData", ""));
nonAuthChans.add(pragma.getAttrB().getAttribute().getBlock().getName() + "__" + pragma.getAttrB().getAttribute().getName().replaceAll("_chData", ""));
}
}
// TraceManager.addDev("nonConfChans " + nonConfChans);
// TraceManager.addDev("nonauthchans " + nonAuthChans);
// TraceManager.addDev("all results displayed");
} catch (Exception e) {
System.out.println("EXCEPTION " + e);
}
}
public TMLMapping<TGComponent> startThread(){
Thread t = new Thread(this);
t.start();
try {
t.join();
}
catch (Exception e){
TraceManager.addDev("Error in Security Generation Thread");
System.out.println("Error in Security Generation Thread");
}
return map;
}
/**
* Issue #204: Accounting for the change in naming tasks
* @param task
* @return
*/
private String getActivityDiagramName( final TMLTask task ) {
if ( task == null || task.getName() == null ) {
return null;
}
final String[] splittedName = task.getName().split( "__");
if ( splittedName.length > 0 ) {
return splittedName[ 1 ];
}
return task.getName();
}
public boolean portInTask(TMLTask task, String portName){
TMLActivityDiagramPanel tad = tmlcdp.getTMLActivityDiagramPanel(task.getName());// FIXME ( getActivityDiagramName( task ) );
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel writeChannel = (TMLADWriteChannel) tg;
if (writeChannel.getChannelName().equals(portName)) {
return true;
}
}
else if (tg instanceof TMLADReadChannel){
TMLADReadChannel readChannel = (TMLADReadChannel) tg;
if (readChannel.getChannelName().equals(portName)) {
return true;
}
}
}
return false;
}
public void run(){
GTMLModeling gtm = new GTMLModeling(newarch, true);
map = gtm.translateToTMLMapping();
// oldmodel = map.getTMLModeling();
Map<TMLTask, HashSet<TMLTask>> toSecure = new HashMap<TMLTask, HashSet<TMLTask>>();
Map<TMLTask, HashSet<TMLTask>> toSecureRev = new HashMap<TMLTask, HashSet<TMLTask>>();
Map<TMLTask, HashSet<String>> secOutChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> secInChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> nonceOutChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> nonceInChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> macOutChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> macInChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> hsmSecInChannels = new HashMap<TMLTask, HashSet<String>>();
Map<TMLTask, HashSet<String>> hsmSecOutChannels = new HashMap<TMLTask, HashSet<String>>();
//TraceManager.addDev("mapping " + map.getSummaryTaskMapping());
// Map<String, HSMChannel> secChannels = new HashMap<String, HSMChannel>();
//Map<String, HSMChannel> hsmChannels = new HashMap<String, HSMChannel>();
for (String cpuName : selectedCPUTasks.keySet()) {
for (String task: selectedCPUTasks.get(cpuName)){
hsmTasks.add(task);
taskHSMMap.put(task, cpuName);
}
hsmChannelMap.put(cpuName, new ArrayList<HSMChannel>());
}
//Proverif Analysis channels
List<String> nonAuthChans = new ArrayList<String>();
List<String> nonConfChans = new ArrayList<String>();
proverifAnalysis(map, nonAuthChans, nonConfChans);
TMLModeling<TGComponent> tmlmodel = map.getTMLModeling();
List<TMLChannel> channels = tmlmodel.getChannels();
for (TMLChannel channel : channels) { for (TMLCPrimitivePort p : channel.ports) {
channel.checkConf = channel.checkConf || p.checkConf;
channel.checkAuth = channel.checkAuth || p.checkAuth;
}
}
//System.out.println("Nonauth " + nonAuthChans);
//System.out.println("NonConf " + nonConfChans);
//Create clone of Component Diagram + Activity diagrams to secure
TGComponent tgcomp = map.getTMLModeling().getTGComponent();
tmlcdp = (TMLComponentDesignPanel) tgcomp.getTDiagramPanel().tp;
// TMLComponentDesignPanel tmlcdp = map.getTMLCDesignPanel();
int ind = gui.tabs.indexOf(tmlcdp);
if (ind == -1) {
TraceManager.addDev("No Component Design Panel");
return;
}
String tabName = gui.getTitleAt(tmlcdp);
String title = tabName;
gui.cloneRenameTab(ind, name);
tmlcdp = (TMLComponentDesignPanel) gui.tabs.get(gui.tabs.size() - 1);
TMLComponentTaskDiagramPanel tcdp = tmlcdp.tmlctdp;
//Create clone of architecture panel and map tasks to it
newarch.renameMapping(tabName, tabName + "_" + name);
for (TMLTask task : map.getTMLModeling().getTasks()) {
HashSet<String> tmp = new HashSet<String>();
HashSet<String> tmp2 = new HashSet<String>();
HashSet<TMLTask> tmp3 = new HashSet<TMLTask>();
HashSet<TMLTask> tmp4 = new HashSet<TMLTask>();
HashSet<String> tmp5 = new HashSet<String>();
HashSet<String> tmp6 = new HashSet<String>();
HashSet<String> tmp7 = new HashSet<String>();
HashSet<String> tmp8 = new HashSet<String>();
HashSet<String> tmp9 = new HashSet<String>();
HashSet<String> tmp10 = new HashSet<String>();
secInChannels.put(task, tmp);
secOutChannels.put(task, tmp2);
toSecure.put(task, tmp3);
toSecureRev.put(task, tmp4);
nonceInChannels.put(task, tmp5);
nonceOutChannels.put(task, tmp6);
macInChannels.put(task, tmp7);
macOutChannels.put(task, tmp8);
hsmSecInChannels.put(task, tmp9);
hsmSecOutChannels.put(task, tmp10);
}
//ToSecure keeps a map of origin task: {dest task} for which security operators need to be added
//ToSecureRev keeps a map of dest task: {origin task} for which security operators need to be added
//SecOutChannels are channels which need symmetric encryption operators added
//SecInChannels are channels which need sym decryption operators added
//nonceInChannels are channels which need to send a nonce before receiving the channel data
//nonceOutChannels are channels which need to receive a nonce before sending the channel data
//macInChannels are channels which need verifymac operators added
//macOutChannels are channels which need mac operators added
//hsmSecInChannels need to send data to the hsm to decrypt after receiving channel data
//hsmSecOutChannels need to send data to the hsm to encrypt before sending channel data
//With the proverif results, check which channels need to be secured
for (TMLTask task : map.getTMLModeling().getTasks()) {
//System.out.println("Task " + task.getName());
//Check if all channel operators are secured TMLActivityDiagramPanel tad = tmlcdp.getTMLActivityDiagramPanel(task.getName()); //FIXME getActivityDiagramName( task ) )
if (tad==null){
continue;
}
for (TMLChannel chan: tmlmodel.getChannels(task)){
//Origin and Destination ports can have different names. Therefore, we need to put both names in the list of channels to secure.
List<String> portNames = new ArrayList<String>();
boolean nonConf = false;
boolean nonAuth = false;
if (chan.isBasicChannel()){
portNames.add(chan.getOriginPort().getName());
portNames.add(chan.getDestinationPort().getName());
if (nonConfChans.contains(chan.getOriginTask().getName().split("__")[1] + "__" + chan.getOriginPort().getName() + "_chData")){
nonConf=true;
}
if (nonAuthChans.contains(chan.getDestinationTask().getName().split("__")[1] + "__" + title + "__" + chan.getDestinationPort().getName())){
nonAuth=true;
}
//When port names are different
if (nonAuthChans.contains(chan.getDestinationTask().getName().split("__")[1] + "__" + chan.getName())){
nonAuth=true;
}
}
else {
for (TMLPort port: chan.getOriginPorts()){
for (TMLTask origTask: chan.getOriginTasks()){
if (nonConfChans.contains(origTask.getName().split("__")[1] + "__" + port.getName() + "_chData")){
nonConf=true;
}
}
portNames.add(port.getName());
}
for (TMLTask destTask: chan.getDestinationTasks()){
for (TMLPort port: chan.getDestinationPorts()){
if (nonAuthChans.contains(destTask.getName().split("__")[1] + "__" + title + "__" + port.getName())){
nonAuth=true;
}
if (!portNames.contains(port.getName())){
portNames.add(port.getName());
}
}
//System.out.println(destTask.getName().split("__")[1] + "__" + chan.getName());
if (nonAuthChans.contains(destTask.getName().split("__")[1] + "__" + chan.getName())){
nonAuth=true;
}
}
//When port names are different
}
// System.out.println("channel " + chan.getName() + " ports " + portNames);
String secName = chan.getName().split("__")[chan.getName().split("__").length-1];
for (String chanName: portNames){
//Classify channels based on the type of security requirements and unsatisfied properties
if (chan.isBasicChannel()){
if (chan.checkConf && autoConf && nonConf) {
toSecure.get(chan.getOriginTask()).add(chan.getDestinationTask());
if (chan.checkAuth && autoStrongAuth) {
if (!toSecureRev.get(chan.getDestinationTask()).contains(chan.getOriginTask())){
toSecureRev.get(chan.getDestinationTask()).add(chan.getOriginTask()); }
}
if (hsmTasks.contains(chan.getOriginTask().getName().split("__")[1])){
channelSecMap.put(chanName, "hsmSec_"+secName);
if (!hsmSecOutChannels.get(chan.getOriginTask()).contains(chanName) && portInTask(chan.getOriginTask(),chanName)){
HSMChannel hsmchan = new HSMChannel(chanName, chan.getOriginTask().getName().split("__")[1], HSMChannel.SENC);
hsmChannelMap.get(taskHSMMap.get(chan.getOriginTask().getName().split("__")[1])).add(hsmchan);
hsmSecOutChannels.get(chan.getOriginTask()).add(chanName);
if (chan.checkAuth && autoStrongAuth) {
nonceOutChannels.get(chan.getOriginTask()).add(chanName);
hsmchan.nonceName="nonce_" + chan.getDestinationTask().getName().split("__")[1] + "_" + chan.getOriginTask().getName().split("__")[1];
}
}
}
else {
if (!secOutChannels.get(chan.getOriginTask()).contains(chanName)) {
secOutChannels.get(chan.getOriginTask()).add(chanName);
channelSecMap.put(chanName, "autoEncrypt_"+secName);
if (chan.checkAuth && autoStrongAuth) {
nonceOutChannels.get(chan.getOriginTask()).add(chanName);
}
}
}
if (hsmTasks.contains(chan.getDestinationTask().getName().split("__")[1])){
if (!hsmSecInChannels.get(chan.getDestinationTask()).contains(chanName) && portInTask(chan.getDestinationTask(),chanName) ) {
HSMChannel hsmchan = new HSMChannel(chanName, chan.getDestinationTask().getName().split("__")[1], HSMChannel.DEC);
hsmChannelMap.get(taskHSMMap.get(chan.getDestinationTask().getName().split("__")[1])).add(hsmchan);
hsmSecInChannels.get(chan.getDestinationTask()).add(chanName);
if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(chan.getDestinationTask()).add(chanName);
hsmchan.nonceName="nonce_" + chan.getDestinationTask().getName().split("__")[1] + "_" + chan.getOriginTask().getName().split("__")[1];
}
}
}
else {
if (!secInChannels.get(chan.getDestinationTask()).contains(chanName)) {
secInChannels.get(chan.getDestinationTask()).add(chanName);
if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(chan.getDestinationTask()).add(chanName);
}
}
}
} else if (chan.checkAuth && autoWeakAuth && nonAuth) {
toSecure.get(chan.getOriginTask()).add(chan.getDestinationTask());
if (autoStrongAuth) {
if (!toSecureRev.get(chan.getDestinationTask()).contains(chan.getOriginTask())){
toSecureRev.get(chan.getDestinationTask()).add(chan.getOriginTask());
}
/*}
else {
TMLChannel chantmp = oldmodel.getChannelByShortName("__"+chan.getName());
System.out.println("Channel found "+ chantmp);
}*/
}
if (hsmTasks.contains(chan.getOriginTask().getName().split("__")[1])){
channelSecMap.put(chanName, "hsmSec_"+secName);
if (!hsmSecOutChannels.get(chan.getOriginTask()).contains(chanName) && portInTask(chan.getOriginTask(),chanName)){
HSMChannel hsmchan = new HSMChannel(chanName, chan.getOriginTask().getName().split("__")[1], HSMChannel.MAC);
hsmChannelMap.get(taskHSMMap.get(chan.getOriginTask().getName().split("__")[1])).add(hsmchan);
hsmSecOutChannels.get(chan.getOriginTask()).add(chanName);
if (autoStrongAuth) {
nonceOutChannels.get(chan.getOriginTask()).add(chanName);
hsmchan.nonceName="nonce_" + chan.getDestinationTask().getName().split("__")[1] + "_" + chan.getOriginTask().getName().split("__")[1];
}
} }
else {
if (!macInChannels.get(chan.getOriginTask()).contains(chanName)) {
macOutChannels.get(chan.getOriginTask()).add(chanName);
channelSecMap.put(chanName, "autoEncrypt_"+secName);
if (autoStrongAuth) {
nonceOutChannels.get(chan.getOriginTask()).add(chanName);
}
}
}
if (hsmTasks.contains(chan.getDestinationTask().getName().split("__")[1])){
if (!hsmSecInChannels.get(chan.getDestinationTask()).contains(chanName) && portInTask(chan.getDestinationTask(),chanName)) {
HSMChannel hsmchan = new HSMChannel(chanName, chan.getDestinationTask().getName().split("__")[1], HSMChannel.DEC);
hsmChannelMap.get(taskHSMMap.get(chan.getDestinationTask().getName().split("__")[1])).add(hsmchan);
hsmSecInChannels.get(chan.getDestinationTask()).add(chanName);
if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(chan.getDestinationTask()).add(chanName);
hsmchan.nonceName="nonce_" + chan.getDestinationTask().getName().split("__")[1] + "_" + chan.getOriginTask().getName().split("__")[1];
}
}
}
else {
if (!secInChannels.get(chan.getDestinationTask()).contains(chanName)) {
secInChannels.get(chan.getDestinationTask()).add(chanName);
if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(chan.getDestinationTask()).add(chanName);
}
}
}
}
}
else {
//Ignore strong authenticity for fork and join channels
//Only add hsm channel for own port
for (TMLTask orig: chan.getOriginTasks()){
for (TMLTask dest:chan.getDestinationTasks()){
if (chan.checkConf && autoConf && nonConf) {
toSecure.get(orig).add(dest);
/*if (chan.checkAuth && autoStrongAuth) {
if (!toSecureRev.get(dest).contains(orig)){
toSecureRev.get(dest).add(orig);
}
}*/
if (hsmTasks.contains(orig.getName().split("__")[1])){
channelSecMap.put(chanName, "hsmSec_"+secName);
if (!hsmSecOutChannels.get(orig).contains(chanName) && portInTask(orig,chanName)){
HSMChannel hsmchan = new HSMChannel(chanName, orig.getName().split("__")[1], HSMChannel.SENC);
hsmChannelMap.get(taskHSMMap.get(orig.getName().split("__")[1])).add(hsmchan);
hsmSecOutChannels.get(orig).add(chanName);
/* if (chan.checkAuth && autoStrongAuth) {
nonceOutChannels.get(orig).add(chanName);
hsmchan.nonceName="nonce_" + dest.getName().split("__")[1] + "_" + orig.getName().split("__")[1];
}*/
}
}
else {
if (!secOutChannels.get(orig).contains(chanName)) {
secOutChannels.get(orig).add(chanName);
channelSecMap.put(chanName, "autoEncrypt_"+secName);
/* if (chan.checkAuth && autoStrongAuth) {
nonceOutChannels.get(orig).add(chanName);
}*/
}
}
if (hsmTasks.contains(dest.getName().split("__")[1])){
if (!hsmSecInChannels.get(dest).contains(chanName) && portInTask(dest,chanName)) {
HSMChannel hsmchan = new HSMChannel(chanName, dest.getName().split("__")[1], HSMChannel.DEC); hsmChannelMap.get(taskHSMMap.get(dest.getName().split("__")[1])).add(hsmchan);
hsmSecInChannels.get(dest).add(chanName);
/* if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(dest).add(chanName);
hsmchan.nonceName="nonce_" + dest.getName().split("__")[1] + "_" + orig.getName().split("__")[1];
}*/
}
}
else {
if (!secInChannels.get(dest).contains(chanName)) {
secInChannels.get(dest).add(chanName);
/*if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(dest).add(chanName);
}*/
}
}
} else if (chan.checkAuth && autoWeakAuth && nonAuth) {
toSecure.get(orig).add(dest);
/* if (autoStrongAuth) {
/* if (chan.getOriginTask().getReferenceObject() instanceof TMLCPrimitiveComponent && chan.getDestinationTask().getReferenceObject() instanceof TMLCPrimitiveComponent){*/
/*if (!toSecureRev.get(dest).contains(orig)){
toSecureRev.get(dest).add(orig);
}*/
/*}
else {
TMLChannel chantmp = oldmodel.getChannelByShortName("__"+chan.getName());
System.out.println("Channel found "+ chantmp);
}
}*/
if (hsmTasks.contains(orig.getName().split("__")[1])){
channelSecMap.put(chanName, "hsmSec_"+secName);
if (!hsmSecOutChannels.get(orig).contains(chanName) && portInTask(orig,chanName)){
HSMChannel hsmchan = new HSMChannel(chanName, orig.getName().split("__")[1], HSMChannel.MAC);
hsmChannelMap.get(taskHSMMap.get(orig.getName().split("__")[1])).add(hsmchan);
hsmSecOutChannels.get(orig).add(chanName);
/*if (autoStrongAuth) {
nonceOutChannels.get(orig).add(chanName);
hsmchan.nonceName="nonce_" + dest.getName().split("__")[1] + "_" + orig.getName().split("__")[1];
}*/
}
}
else {
if (!macInChannels.get(orig).contains(chanName)) {
macOutChannels.get(orig).add(chanName);
channelSecMap.put(chanName, "autoEncrypt_"+secName);
/* if (autoStrongAuth) {
nonceOutChannels.get(orig).add(chanName);
}*/
}
}
if (hsmTasks.contains(dest.getName().split("__")[1])){
if (!hsmSecInChannels.get(dest).contains(chanName) && portInTask(dest,chanName)) {
HSMChannel hsmchan = new HSMChannel(chanName, dest.getName().split("__")[1], HSMChannel.DEC);
hsmChannelMap.get(taskHSMMap.get(dest.getName().split("__")[1])).add(hsmchan);
hsmSecInChannels.get(dest).add(chanName);
/*if (chan.checkAuth && autoStrongAuth) {
nonceInChannels.get(dest).add(chanName);
hsmchan.nonceName="nonce_" + dest.getName().split("__")[1] + "_" + orig.getName().split("__")[1];
}*/
}
}
else {
if (!secInChannels.get(dest).contains(chanName)) {
secInChannels.get(dest).add(chanName);
/*if (chan.checkAuth && autoStrongAuth) { nonceInChannels.get(dest).add(chanName);
}*/
}
}
}
}
}
}
}
}
}
// System.out.println("hsmchannelmap" + hsmChannelMap);
TraceManager.addDev("secChannelMap" + channelSecMap);
TraceManager.addDev("macoutchans " + macOutChannels);
TraceManager.addDev("macinchans " + macInChannels);
TraceManager.addDev("nonsecin " + secInChannels);
TraceManager.addDev("nonsecout " + secOutChannels);
TraceManager.addDev("noncein " + nonceInChannels);
TraceManager.addDev("nonceout " + nonceOutChannels);
TraceManager.addDev("hsmsecin " + hsmSecInChannels);
TraceManager.addDev("hsmsecout " + hsmSecOutChannels);
TraceManager.addDev("tosecrev " + toSecureRev);
//Add a HSM Task for each selected CPU on the component diagram, add associated channels, etc
for (String cpuName : selectedCPUTasks.keySet()) {
TMLCPrimitiveComponent hsm = new TMLCPrimitiveComponent(0, tcdp.getMaxY()-200, tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxY(), false, null, tcdp);
TAttribute index = new TAttribute(2, "channelIndex", "0", 0);
hsm.getAttributeList().add(index);
tcdp.addComponent(hsm, 0, 500, false, true);
hsm.setValueWithChange("HSM_" + cpuName);
//Find all associated components
List<TMLCPrimitiveComponent> comps = new ArrayList<TMLCPrimitiveComponent>();
//Find the component to add a HSM to
for (TGComponent tg : tcdp.getComponentList()) {
if (tg instanceof TMLCPrimitiveComponent) {
for (String compName : selectedCPUTasks.get(cpuName)) {
if (tg.getValue().equals(compName)) {
comps.add((TMLCPrimitiveComponent) tg);
break;
}
}
} else if (tg instanceof TMLCCompositeComponent) {
TMLCCompositeComponent cc = (TMLCCompositeComponent) tg;
List<TMLCPrimitiveComponent> pcomps = cc.getAllPrimitiveComponents();
for (TMLCPrimitiveComponent pc : pcomps) {
for (String compName : selectedCPUTasks.get(cpuName)) {
if (pc.getValue().equals(compName)) {
comps.add(pc);
break;
}
}
}
}
}
if (comps.size() == 0) {
//System.out.println("No Components found");
continue;
}
for (TMLCPrimitiveComponent comp : comps) {
//Map<String, HSMChannel> compChannels = new HashMap<String, HSMChannel>();
//String compName = comp.getValue();
List<ChannelData> hsmChans = new ArrayList<ChannelData>(); ChannelData chd = new ChannelData("startHSM_" + cpuName, false, false);
hsmChans.add(chd);
for (HSMChannel hsmChan : hsmChannelMap.get(cpuName)) {
if (!hsmChan.task.equals(comp.getValue())){
continue;
}
if (!channelIndexMap.containsKey(hsmChan.name)){
channelIndexMap.put(hsmChan.name,channelIndex);
channelIndex++;
}
chd = new ChannelData("data_" + hsmChan.name + "_" + hsmChan.task, false, true);
hsmChans.add(chd);
chd = new ChannelData("retData_" + hsmChan.name + "_" + hsmChan.task, true, true);
hsmChans.add(chd);
}
for (ChannelData hsmChan : hsmChans) {
TMLCChannelOutPort originPort = new TMLCChannelOutPort(comp.getX(), comp.getY(), tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, hsm, tcdp);
TMLCChannelOutPort destPort = new TMLCChannelOutPort(comp.getX(), comp.getY(), tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, comp, tcdp);
originPort.commName = hsmChan.name;
originPort.isOrigin = hsmChan.isOrigin;
tcdp.addComponent(originPort, hsm.getX(), hsm.getY(), true, true);
destPort.commName = hsmChan.name;
if (!hsmChan.isChan) {
originPort.typep = 2;
destPort.typep = 2;
originPort.setParam(0, new TType(1));
destPort.setParam(0, new TType(1));
}
destPort.isOrigin = !hsmChan.isOrigin;
tcdp.addComponent(destPort, comp.getX(), comp.getY(), true, true);
TMLCPortConnector conn = new TMLCPortConnector(0, 0, tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, null, tcdp, originPort.getTGConnectingPointAtIndex(0), destPort.getTGConnectingPointAtIndex(0), new Vector<Point>());
tcdp.addComponent(conn, 0, 0, false, true);
}
}
}
for (String cpuName : selectedCPUTasks.keySet()) {
buildHSMActivityDiagram(cpuName);
//Add a private bus to Hardware Accelerator with the task for hsm
//Find the CPU the task is mapped to
TMLArchiDiagramPanel archPanel = newarch.tmlap;
TMLArchiCPUNode cpu = null;
String refTask = "";
for (TGComponent tg : archPanel.getComponentList()) {
if (tg instanceof TMLArchiCPUNode) {
if (tg.getName().equals(cpuName)) {
cpu = (TMLArchiCPUNode) tg;
TMLArchiArtifact art = cpu.getArtifactList().get(0);
refTask = art.getReferenceTaskName();
break;
}
}
}
if (cpu == null) {
return;
}
//Add new memory
TMLArchiMemoryNode mem = new TMLArchiMemoryNode(cpu.getX(), archPanel.getMaxY()-800, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel);
archPanel.addComponent(mem, cpu.getX(), archPanel.getMaxY()-400, false, true);
mem.setName("HSMMemory_" + cpuName);
//Add Hardware Accelerator
TMLArchiHWANode hwa = new TMLArchiHWANode(cpu.getX(), archPanel.getMaxY()-300, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel);
archPanel.addComponent(hwa, cpu.getX() + 100, cpu.getY() + 100, false, true);
hwa.setName("HSM_" + cpuName);
//Add hsm task to hwa
TMLArchiArtifact hsmArt = new TMLArchiArtifact(cpu.getX(), archPanel.getMaxY()- 280, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, hwa, archPanel);
archPanel.addComponent(hsmArt, cpu.getX() + 100, archPanel.getMaxY()- 280, true, true);
hsmArt.setFullName("HSM_" + cpuName, refTask);
//Add bus connecting the cpu and HWA
TMLArchiBUSNode bus = new TMLArchiBUSNode(cpu.getX() + 50, archPanel.getMaxY() -500, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel);
bus.setPrivacy(1);
bus.setName("HSMBus_" + cpuName);
archPanel.addComponent(bus, cpu.getX() + 200, cpu.getY() + 200, false, true);
//Connect Bus and CPU
TMLArchiConnectorNode connect = new TMLArchiConnectorNode(cpu.getX() + 100, archPanel.getMaxY() -300, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel, null, null, new Vector<Point>());
TGConnectingPoint p1 = bus.findFirstFreeTGConnectingPoint(true, true);
p1.setFree(false);
connect.setP2(p1);
TGConnectingPoint p2 = cpu.findFirstFreeTGConnectingPoint(true, true);
p2.setFree(false);
connect.setP1(p2);
archPanel.addComponent(connect, cpu.getX() + 100, cpu.getY() + 100, false, true);
//Connect Bus and HWA
connect = new TMLArchiConnectorNode(cpu.getX() + 100, cpu.getY() + 100, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel, null, null, new Vector<Point>());
p1 = bus.findFirstFreeTGConnectingPoint(true, true);
p1.setFree(false);
connect.setP2(p1);
p2 = hwa.findFirstFreeTGConnectingPoint(true, true);
p2.setFree(false);
connect.setP1(p2);
archPanel.addComponent(connect, cpu.getX() + 100, cpu.getY() + 100, false, true);
//Connect Bus and Memory
connect = new TMLArchiConnectorNode(cpu.getX() + 100, cpu.getY() + 100, archPanel.getMinX(), archPanel.getMaxX(), archPanel.getMinY(), archPanel.getMaxY(), true, null, archPanel, null, null, new Vector<Point>());
p1 = bus.findFirstFreeTGConnectingPoint(true, true);
p1.setFree(false);
connect.setP2(p1);
p2 = mem.findFirstFreeTGConnectingPoint(true, true);
p2.setFree(false);
connect.setP1(p2);
archPanel.addComponent(connect, cpu.getX() + 100, cpu.getY() + 100, false, true);
}
//
// int num=0;
//int nonceNum=0;
//Create reverse channels on component diagram to send nonces if they don't already exist
for (TMLTask task : toSecureRev.keySet()) {
// TraceManager.addDev("Adding nonces to " + task.getName());
List<TMLChannel> chans = tmlmodel.getChannelsFromMe(task);
for (TMLTask task2 : toSecureRev.get(task)) {
boolean addChan = true;
for (TMLChannel chan : chans) {
if (chan.getDestinationTask() == task2) {
addChan = false;
}
}
if (addChan) {
TMLCChannelOutPort originPort = new TMLCChannelOutPort(0, 0, tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, null, tcdp);
TMLCChannelOutPort destPort = new TMLCChannelOutPort(0, 0, tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, null, tcdp);
if (task.getReferenceObject() instanceof TMLCPrimitiveComponent){
TGComponent tg = (TGComponent) task.getReferenceObject();
originPort = new TMLCChannelOutPort(tg.getX(), tg.getY(), tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, tg, tcdp);
originPort.commName = "nonceCh" + task.getName().split("__")[1] + "_" + task2.getName().split("__")[1];
tcdp.addComponent(originPort, tg.getX(), tg.getY(), true, true);
}
if (task2.getReferenceObject() instanceof TMLCPrimitiveComponent){
TGComponent tg = (TGComponent) task2.getReferenceObject();
destPort = new TMLCChannelOutPort(tg.getX(), tg.getY(), tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, tg, tcdp);
destPort.isOrigin = false;
destPort.commName = "nonceCh" + task.getName().split("__")[1] + "_" + task2.getName().split("__")[1];
tcdp.addComponent(destPort, tg.getX(), tg.getY(), true, true);
}
tmlmodel.addChannel(new TMLChannel("nonceCh" + task.getName().split("__")[1] + "_" + task2.getName().split("__")[1], originPort));
//Add connection
TMLCPortConnector conn = new TMLCPortConnector(0, 0, tcdp.getMinX(), tcdp.getMaxX(), tcdp.getMinY(), tcdp.getMaxX(), true, null, tcdp, originPort.getTGConnectingPointAtIndex(0), destPort.getTGConnectingPointAtIndex(0), new Vector<Point>());
tcdp.addComponent(conn, 0, 0, false, true);
}
}
}
// }
//Add encryption/nonces to activity diagram
for (TMLTask task : toSecure.keySet()) {
TraceManager.addDev("Securing task " + task.getName());
TMLActivityDiagramPanel tad = tmlcdp.getTMLActivityDiagramPanel(task.getName());
if (tad==null){
continue;
}
//Get start state position, shift everything down
int xpos = 0;
int ypos = 0;
TGConnector fromStart = new TGConnectorTMLAD(0, 0, 0, 0, 0, 0, false, null, tad, null, null, new Vector<Point>());
TGConnectingPoint point = new TGConnectingPoint(null, 0, 0, false, false);
//Find states immediately before the write channel operator
//For each occurence of a write channel operator, add encryption/nonces before it
for (String channel : secOutChannels.get(task)) {
Set<TGComponent> channelInstances = new HashSet<TGComponent>();
int yShift = 50;
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + channel);
if (tmlc==null){
//Find by origin port instead
tmlc = tmlmodel.getChannelByOriginPortName(channel);
}
if (tmlc==null){
continue;
}
//First, find the connector that points to it. We will add the encryption, nonce operators directly before the write channel operator
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel writeChannel = (TMLADWriteChannel) tg;
if (writeChannel.getChannelName().equals(channel) && writeChannel.getSecurityContext().equals("")) {
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
for (TGComponent comp : channelInstances) { yShift=50;
//TMLADWriteChannel writeChannel = (TMLADWriteChannel) comp;
xpos = comp.getX();
ypos = comp.getY();
fromStart = tad.findTGConnectorEndingAt(comp.getTGConnectingPointAtIndex(0));
point = fromStart.getTGConnectingPointP2();
//Add encryption operator
TMLADEncrypt enc = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
TMLADReadChannel rd = new TMLADReadChannel(0, 0, 0, 0, 0, 0, false, null, tad);
if (nonceOutChannels.get(task).contains(channel)) {
//Receive any nonces if ensuring authenticity
rd = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//System.out.println("tmlc " + tmlc);
// System.out.println("Checking "+ tmlc.getDestinationTask() + " " + tmlc.getOriginTask());
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
if (matches.size() > 0) {
rd.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
rd.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
rd.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(rd, xpos, ypos + yShift, false, true);
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(enc.getX(), enc.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
yShift += 60;
//Move encryption operator after receive nonce component
enc.setCd(xpos, ypos + yShift);
if (tmlc != null) {
enc.nonce = "nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1];
}
}
enc.securityContext = channelSecMap.get(channel);
enc.type = "Symmetric Encryption";
enc.message_overhead = overhead;
enc.encTime = encComp;
enc.decTime = decComp;
tad.addComponent(enc, xpos, ypos + yShift, false, true);
yShift += 60;
fromStart.setP2(enc.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(enc.getX(), enc.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(enc.getTGConnectingPointAtIndex(1));
//Direct the last TGConnector back to the start of the write channel operator
fromStart.setP2(point);
//Shift components down to make room for the added ones, and add security contexts to write channels
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel wChannel = (TMLADWriteChannel) tg;
if (channel.equals(wChannel.getChannelName()) && wChannel.getSecurityContext().equals("")) {
wChannel.setSecurityContext(channelSecMap.get(channel));
wChannel.setEncForm(true);
}
}
if (tg.getY() >= ypos && tg != enc && tg != rd) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
tad.repaint();
}
}
for (String channel : macOutChannels.get(task)) { //Add MAC before writechannel
int yShift = 50;
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + channel);
//First, find the connector that points to it. We will add the encryption, nonce operators directly before the write channel operator
if (tmlc ==null){
tmlc = tmlmodel.getChannelByOriginPortName(channel);
}
if (tmlc ==null){
continue;
}
Set<TGComponent> channelInstances = new HashSet<TGComponent>();
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel writeChannel = (TMLADWriteChannel) tg;
if (writeChannel.getChannelName().equals(channel) && writeChannel.getSecurityContext().equals("")) {
xpos = tg.getX();
ypos = tg.getY();
fromStart = tad.findTGConnectorEndingAt(tg.getTGConnectingPointAtIndex(0));
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
for (TGComponent comp : channelInstances) {
yShift=50;
//TMLADWriteChannel writeChannel = (TMLADWriteChannel) comp;
xpos = comp.getX();
ypos = comp.getY();
fromStart = tad.findTGConnectorEndingAt(comp.getTGConnectingPointAtIndex(0));
point = fromStart.getTGConnectingPointP2();
TMLADEncrypt enc = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//If we need to receive a nonce
TMLADReadChannel rd = new TMLADReadChannel(0, 0, 0, 0, 0, 0, false, null, tad);
if (nonceOutChannels.get(task).contains(channel)) {
//Receive any nonces if ensuring authenticity
rd = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
if (matches.size() > 0) {
rd.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
rd.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
rd.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(rd, xpos, ypos + yShift, false, true);
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(enc.getX(), enc.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
yShift += 60;
//Move encryption operator after receive nonce component
enc.setCd(xpos, ypos + yShift);
if (tmlc != null) {
enc.nonce = "nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1];
}
}
//Add encryption operator
enc.securityContext = channelSecMap.get(channel);
enc.type = "MAC";
enc.message_overhead = overhead;
enc.encTime = encComp;
enc.decTime = decComp;
enc.size = overhead;
tad.addComponent(enc, xpos, ypos + yShift, false, true);
yShift += 60; fromStart.setP2(enc.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(enc.getX(), enc.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(enc.getTGConnectingPointAtIndex(1));
//Direct the last TGConnector back to the start of the write channel operator
fromStart.setP2(point);
//Shift components down to make room for the added ones, and add security contexts to write channels
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel wChannel = (TMLADWriteChannel) tg;
if (channel.equals(wChannel.getChannelName()) && wChannel.getSecurityContext().equals("")) {
wChannel.setSecurityContext(channelSecMap.get(channel));
wChannel.setEncForm(true);
tad.repaint();
}
}
if (tg.getY() >= ypos && tg != enc && tg != rd) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
}
}
for (String channel: hsmSecOutChannels.get(task)){
Set<TGComponent> channelInstances = new HashSet<TGComponent>();
//TGConnector conn = new TGConnectorTMLAD(0, 0, 0, 0, 0, 0, false, null, tad, null, null, new Vector<Point>());
//TGConnectingPoint next = new TGConnectingPoint(null, 0, 0, false, false);
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADWriteChannel) {
TMLADWriteChannel writeChannel = (TMLADWriteChannel) tg;
if (writeChannel.getChannelName().equals(channel) && writeChannel.getSecurityContext().equals("")) {
fromStart = tad.findTGConnectorEndingAt(tg.getTGConnectingPointAtIndex(0));
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
for (TGComponent chan : channelInstances) {
TMLADWriteChannel writeChannel = (TMLADWriteChannel) chan;
String chanName = writeChannel.getChannelName();
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + chanName);
if (tmlc ==null){
tmlc = tmlmodel.getChannelByOriginPortName(channel);
}
if (tmlc ==null){
continue;
}
writeChannel.setSecurityContext(channelSecMap.get(chanName));
writeChannel.setEncForm(true);
xpos = chan.getX();
ypos = chan.getY();
fromStart = tad.findTGConnectorEndingAt(chan.getTGConnectingPointAtIndex(0));
point = fromStart.getTGConnectingPointP2();
int yShift = 50;
TMLADSendRequest req = new TMLADSendRequest(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
req.setRequestName("startHSM_" + taskHSMMap.get(task.getName().split("__")[1]));
req.setParam(0, Integer.toString(channelIndexMap.get(chanName)));
req.makeValue();
tad.addComponent(req, xpos, ypos + yShift, false, true);
fromStart.setP2(req.getTGConnectingPointAtIndex(0));
//tad.addComponent(fromStart, xpos, ypos, false, true);
//Add connection
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(req.getTGConnectingPointAtIndex(1));
TMLADWriteChannel wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
yShift += 50;
//Add write channel operator
wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr.setChannelName("data_" + chanName + "_" + task.getName().split("__")[1]);
wr.setEncForm(false);
wr.setSecurityContext(channelSecMap.get(chanName));
tad.addComponent(wr, xpos, ypos + yShift, false, true);
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
TMLADReadChannel rd = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
TMLADWriteChannel wr2 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//Receive any nonces if ensuring authenticity
if (nonceOutChannels.get(task).contains(channel)) {
//Read nonce from rec task
yShift+=50;
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
rd = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
if (matches.size() > 0) {
rd.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
rd.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
rd.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(rd, xpos, ypos + yShift, false, true);
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(rd.getX(), rd.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
//Also send nonce to hsm
yShift+=50;
wr2 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr2.setChannelName("data_" + chanName + "_" + task.getName().split("__")[1]);
wr2.setSecurityContext(channelSecMap.get(chanName));
tad.addComponent(wr2, xpos, ypos + yShift, false, true);
TGConnectorTMLAD tmp = new TGConnectorTMLAD(wr2.getX(), wr2.getY() + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, rd.getTGConnectingPointAtIndex(1), wr2.getTGConnectingPointAtIndex(0), new Vector<Point>());
tad.addComponent(tmp, xpos, ypos, false, true);
fromStart.setP2(wr2.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(rd.getX(), rd.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(wr2.getTGConnectingPointAtIndex(1));
yShift += 60;
}
//Read channel operator to receive hsm data
yShift += 60;
TMLADReadChannel rd2 = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
rd2.setChannelName("retData_" + chanName + "_" + task.getName().split("__")[1]);
rd2.setSecurityContext(channelSecMap.get(chanName));
tad.addComponent(rd2, xpos, ypos + yShift, false, true);
fromStart.setP2(rd2.getTGConnectingPointAtIndex(0));
yShift += 50;
//Add connector
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(rd2.getTGConnectingPointAtIndex(1));
yShift += 50;
//Direct the last TGConnector back to the start of the write channel operator
fromStart.setP2(point);
//Shift components down to make room for the added ones, and add security contexts to write channels
for (TGComponent tg : tad.getComponentList()) {
if (tg.getY() >= ypos && tg != wr && tg != req && tg != rd && tg!=wr2 && tg!=rd2) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
tad.repaint();
}
}
for (String channel: hsmSecInChannels.get(task)){
//System.out.println("Checking hsmsecinchannel " + channel + " " + task.getName());
Set<TGComponent> channelInstances = new HashSet<TGComponent>();
//TGConnector conn = new TGConnectorTMLAD(0, 0, 0, 0, 0, 0, false, null, tad, null, null, new Vector<Point>());
//TGConnectingPoint next = new TGConnectingPoint(null, 0, 0, false, false);
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADReadChannel) {
TMLADReadChannel readChannel = (TMLADReadChannel) tg;
if (readChannel.getChannelName().equals(channel) && readChannel.getSecurityContext().equals("")) {
fromStart = tad.findTGConnectorEndingAt(tg.getTGConnectingPointAtIndex(0));
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
//System.out.println("matches " + channelInstances);
for (TGComponent chan : channelInstances) {
TMLADReadChannel readChannel = (TMLADReadChannel) chan;
String chanName = readChannel.getChannelName();
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + chanName);
if (tmlc ==null){
tmlc = tmlmodel.getChannelByDestinationPortName(channel);
}
if (tmlc ==null){
continue;
}
readChannel.setSecurityContext(channelSecMap.get(chanName)); readChannel.setEncForm(true);
xpos = chan.getX()+1;
ypos = chan.getY()+1;
fromStart = tad.findTGConnectorStartingAt(chan.getTGConnectingPointAtIndex(1));
point = fromStart.getTGConnectingPointP2();
int yShift = 50;
TMLADSendRequest req = new TMLADSendRequest(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
req.setRequestName("startHSM_" + taskHSMMap.get(task.getName().split("__")[1]));
req.setParam(0, Integer.toString(channelIndexMap.get(chanName)));
req.makeValue();
tad.addComponent(req, xpos, ypos + yShift, false, true);
fromStart.setP2(req.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, xpos, ypos, false, true);
//Add connection
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(req.getTGConnectingPointAtIndex(1));
TMLADWriteChannel wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
yShift += 50;
//Add write channel operator
wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr.setChannelName("data_" + chanName + "_" + task.getName().split("__")[1]);
wr.setSecurityContext(channelSecMap.get(chanName));
wr.makeValue();
tad.addComponent(wr, xpos, ypos + yShift, false, true);
//Add connector between request and write
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, xpos, ypos, false, true);
//Add connector between write and ???
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
//If needed, forge nonce, send it to receiving task
TMLADEncrypt nonce = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
TMLADWriteChannel wr3 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
TMLADWriteChannel wr2 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
if (nonceInChannels.get(task).contains(channel)) {
//Create a nonce operator and a write channel operator
yShift+=60;
nonce = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
nonce.securityContext = "nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1];
nonce.type = "Nonce";
nonce.message_overhead = overhead;
nonce.encTime = encComp;
nonce.decTime = decComp;
tad.addComponent(nonce, xpos, ypos + yShift, false, true);
fromStart.setP2(nonce.getTGConnectingPointAtIndex(0));
yShift += 50;
wr3 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//Send nonce along channel, the newly created nonce channel or an existing channel with the matching sender and receiver
//Find matching channels
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
if (matches.size() > 0) {
wr3.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
wr3.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
//send the nonce along the channel
wr3.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(wr3, xpos, ypos + yShift, false, true);
wr3.makeValue();
TGConnector tmp = new TGConnectorTMLAD(wr3.getX(), wr3.getY() + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, nonce.getTGConnectingPointAtIndex(1), wr3.getTGConnectingPointAtIndex(0), new Vector<Point>());
tad.addComponent(tmp, xpos, ypos, false, true);
//Also send nonce to hsm
yShift+=50;
wr2 = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr2.setChannelName("data_" + chanName + "_" + task.getName().split("__")[1]);
wr2.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(wr2, xpos, ypos + yShift, false, true);
tmp = new TGConnectorTMLAD(wr2.getX(), wr2.getY() + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, wr3.getTGConnectingPointAtIndex(1), wr2.getTGConnectingPointAtIndex(0), new Vector<Point>());
tad.addComponent(tmp, xpos, ypos, false, true);
fromStart = new TGConnectorTMLAD(wr2.getX(), wr.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, wr2.getTGConnectingPointAtIndex(1), null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
//Connect created write channel operator to start of read channel operator
fromStart.setP1(wr2.getTGConnectingPointAtIndex(1));
fromStart.setP2(point);
/* //Shift everything from the read channel on down
for (TGComponent tg : tad.getComponentList()) {
if (tg.getY() >= ypos && tg != nonce && tg != wr2 && tg!=wr3) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}*/
}
//Add read channel operator
yShift += 60;
TMLADReadChannel rd = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
rd.setChannelName("retData_" + chanName + "_" + task.getName().split("__")[1]);
rd.setSecurityContext(channelSecMap.get(chanName));
rd.setEncForm(false);
tad.addComponent(rd, xpos, ypos + yShift, false, true);
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
yShift += 50;
//Add connector
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
yShift += 50;
//Direct the last TGConnector back to the start of the operator after the read channel
fromStart.setP2(point);
//Shift components down to make room for the added ones, and add security contexts to write channels
for (TGComponent tg : tad.getComponentList()) {
if (tg.getY() >= ypos && tg != wr && tg != req && tg != rd && tg!=wr2 && tg!=nonce && tg!=wr3) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
tad.repaint();
}
}
for (String channel : macInChannels.get(task)) {
//Add decryptmac after readchannel
int yShift = 50;
Set<TGComponent> channelInstances = new HashSet<TGComponent>();
TGConnector conn = new TGConnectorTMLAD(0, 0, 0, 0, 0, 0, false, null, tad, null, null, new Vector<Point>());
TGConnectingPoint next = new TGConnectingPoint(null, 0, 0, false, false);
//Find read channel operator
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + channel);
if (tmlc ==null){
tmlc = tmlmodel.getChannelByDestinationPortName(channel);
}
if (tmlc ==null){
continue;
}
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADReadChannel) {
TMLADReadChannel readChannel = (TMLADReadChannel) tg;
if (readChannel.getChannelName().equals(channel) && readChannel.getSecurityContext().equals("")) {
fromStart = tad.findTGConnectorEndingAt(tg.getTGConnectingPointAtIndex(0));
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
for (TGComponent comp : channelInstances) {
yShift=50;
fromStart = tad.findTGConnectorEndingAt(comp.getTGConnectingPointAtIndex(0));
point = fromStart.getTGConnectingPointP2();
conn = tad.findTGConnectorStartingAt(comp.getTGConnectingPointAtIndex(1));
next = conn.getTGConnectingPointP2();
xpos = fromStart.getX();
ypos = fromStart.getY();
TMLADReadChannel readChannel = (TMLADReadChannel) comp;
readChannel.setSecurityContext(channelSecMap.get(readChannel.getChannelName()));
tad.repaint();
TMLADWriteChannel wr = new TMLADWriteChannel(0, 0, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//Create nonce and send it
if (nonceInChannels.get(task).contains(channel)) {
//Create a nonce operator and a write channel operator
TMLADEncrypt nonce = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
nonce.securityContext = "nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1];
nonce.type = "Nonce";
nonce.message_overhead = overhead;
nonce.encTime = encComp;
nonce.decTime = decComp;
tad.addComponent(nonce, xpos, ypos + yShift, false, true);
fromStart.setP2(nonce.getTGConnectingPointAtIndex(0));
yShift += 50;
wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//Send nonce along channel, the newly created nonce channel or an existing channel with the matching sender and receiver //Find matching channels
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
if (matches.size() > 0) {
wr.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
wr.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
//send the nonce along the channel
wr.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(wr, xpos, ypos + yShift, false, true);
wr.makeValue();
TGConnector tmp = new TGConnectorTMLAD(wr.getX(), wr.getY() + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, nonce.getTGConnectingPointAtIndex(1), wr.getTGConnectingPointAtIndex(0), new Vector<Point>());
tad.addComponent(tmp, xpos, ypos, false, true);
fromStart = new TGConnectorTMLAD(wr.getX(), wr.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, wr.getTGConnectingPointAtIndex(1), null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
//Connect created write channel operator to start of read channel operator
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
fromStart.setP2(point);
yShift+=40;
//Shift everything from the read channel on down
for (TGComponent tg : tad.getComponentList()) {
if ((tg.getY() >= ypos && tg != nonce && tg != wr) || tg == readChannel) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
}
//Add decryption operator if it does not already exist
xpos = conn.getX();
ypos = conn.getY();
TMLADDecrypt dec = new TMLADDecrypt(xpos + 10, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
dec.securityContext = channelSecMap.get(readChannel.getChannelName());
tad.addComponent(dec, dec.getX(), dec.getY(), false, true);
conn.setP2(dec.getTGConnectingPointAtIndex(0));
yShift += 60;
conn = new TGConnectorTMLAD(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, dec.getTGConnectingPointAtIndex(1), next, new Vector<Point>());
conn.setP1(dec.getTGConnectingPointAtIndex(1));
conn.setP2(next);
tad.addComponent(conn, conn.getX(), conn.getY(), false, true);
//Shift everything down
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADReadChannel) {
readChannel = (TMLADReadChannel) tg;
if (channel.equals(readChannel.getChannelName()) && readChannel.getSecurityContext().equals("")) {
readChannel.setSecurityContext(channelSecMap.get(readChannel.getChannelName()));
readChannel.setEncForm(true);
}
}
if (tg.getY() >= ypos && tg != dec && tg != comp) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
tad.repaint();
}
}
for (String channel : secInChannels.get(task)) {
TraceManager.addDev("securing channel " + channel);
int yShift = 20;
// String title = task.getName().split("__")[0];
TGConnector conn = new TGConnectorTMLAD(0, 0, 0, 0, 0, 0, false, null, tad, null, null, new Vector<Point>());
TGConnectingPoint next = new TGConnectingPoint(null, 0, 0, false, false); //Find read channel operator
TMLChannel tmlc = tmlmodel.getChannelByName(title + "__" + channel);
if (tmlc ==null){
tmlc = tmlmodel.getChannelByDestinationPortName(channel);
}
if (tmlc ==null){
continue;
}
TMLADReadChannel readChannel = new TMLADReadChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
HashSet<TGComponent> channelInstances = new HashSet<TGComponent>();
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADReadChannel) {
readChannel = (TMLADReadChannel) tg;
if (readChannel.getChannelName().equals(channel) && readChannel.getSecurityContext().equals("")) {
fromStart = tad.findTGConnectorEndingAt(tg.getTGConnectingPointAtIndex(0));
if (fromStart != null) {
channelInstances.add(tg);
}
}
}
}
for (TGComponent comp : channelInstances) {
yShift=30;
readChannel = (TMLADReadChannel) comp;
fromStart = tad.findTGConnectorEndingAt(comp.getTGConnectingPointAtIndex(0));
point = fromStart.getTGConnectingPointP2();
conn = tad.findTGConnectorStartingAt(comp.getTGConnectingPointAtIndex(1));
next = conn.getTGConnectingPointP2();
xpos = comp.getX();
ypos = comp.getY();
TMLADWriteChannel wr = new TMLADWriteChannel(0, 0, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
TMLADEncrypt nonce = new TMLADEncrypt(0, 0, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
if (nonceInChannels.get(task).contains(channel)) {
//Create a nonce operator and a write channel operator
nonce = new TMLADEncrypt(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
nonce.securityContext = "nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1];
nonce.type = "Nonce";
nonce.message_overhead = overhead;
nonce.encTime = encComp;
nonce.decTime = decComp;
tad.addComponent(nonce, xpos, ypos + yShift, false, true);
fromStart.setP2(nonce.getTGConnectingPointAtIndex(0));
yShift += 50;
wr = new TMLADWriteChannel(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
//Send nonce along channel, the newly created nonce channel or an existing channel with the matching sender and receiver
//Find matching channels
List<TMLChannel> matches = tmlmodel.getChannels(tmlc.getDestinationTask(), tmlc.getOriginTask());
if (matches.size() > 0) {
wr.setChannelName(matches.get(0).getName().replaceAll(title + "__", ""));
} else {
wr.setChannelName("nonceCh" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
}
yShift+=40;
//send the nonce along the channel
wr.setSecurityContext("nonce_" + tmlc.getDestinationTask().getName().split("__")[1] + "_" + tmlc.getOriginTask().getName().split("__")[1]);
tad.addComponent(wr, xpos, ypos + yShift, false, true);
wr.makeValue();
TGConnector tmp = new TGConnectorTMLAD(wr.getX(), wr.getY() + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, nonce.getTGConnectingPointAtIndex(1), wr.getTGConnectingPointAtIndex(0), new Vector<Point>());
tad.addComponent(tmp, xpos, ypos, false, true);
fromStart = new TGConnectorTMLAD(wr.getX(), wr.getY(), tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, wr.getTGConnectingPointAtIndex(1), null, new Vector<Point>());
tad.addComponent(fromStart, xpos, ypos, false, true);
//Connect created write channel operator to start of read channel operator
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
fromStart.setP2(point);
//Shift everything from the read channel on down
for (TGComponent tg : tad.getComponentList()) {
if ((tg.getY() >= ypos && tg != nonce && tg != wr)) {
tg.setCd(tg.getX(), tg.getY() + yShift); }
}
}
//tad.repaint();
//Now add the decrypt operator
yShift += 40;
readChannel.setSecurityContext(channelSecMap.get(readChannel.getChannelName()));
readChannel.setEncForm(true);
tad.repaint();
//Add decryption operator if it does not already exist
xpos = readChannel.getX();
ypos = readChannel.getY();
TMLADDecrypt dec = new TMLADDecrypt(xpos + 10, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
dec.securityContext = channelSecMap.get(readChannel.getChannelName());
tad.addComponent(dec, dec.getX(), dec.getY(), false, true);
conn.setP2(dec.getTGConnectingPointAtIndex(0));
yShift += 60;
conn = new TGConnectorTMLAD(xpos, ypos + yShift, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, dec.getTGConnectingPointAtIndex(1), next, new Vector<Point>());
conn.setP1(dec.getTGConnectingPointAtIndex(1));
conn.setP2(next);
tad.addComponent(conn, conn.getX(), conn.getY(), false, true);
//Shift everything down
for (TGComponent tg : tad.getComponentList()) {
if (tg instanceof TMLADReadChannel) {
readChannel = (TMLADReadChannel) tg;
if (channel.equals(readChannel.getChannelName()) && readChannel.getSecurityContext().equals("")) {
readChannel.setSecurityContext( channelSecMap.get(readChannel.getChannelName()));
readChannel.setEncForm(true);
}
}
if (tg.getY() >= ypos && tg != dec && tg!= wr && tg != nonce && tg!= comp) {
tg.setCd(tg.getX(), tg.getY() + yShift);
}
}
tad.setMaxPanelSize(tad.getMaxX(), tad.getMaxY() + yShift);
tad.repaint();
}
}
}
// GTMLModeling gtm = new GTMLModeling(newarch, false);
// map = gtm.translateToTMLMapping();
//if (gtm.getCheckingErrors().size() > 0){
//System.out.println("@$()(#");
//map= null;
// }
/*for (TMLTask task : newmodel.getTasks()) {
task.setName(tabName + "_" + name + "__" + task.getName());
}
for (TMLTask task : tmlmodel.getTasks()) {
HwExecutionNode node = (HwExecutionNode) map.getHwNodeOf(task);
if (newmodel.getTMLTaskByName(task.getName().replace(tabName, tabName + "_" + name)) != null) {
map.addTaskToHwExecutionNode(newmodel.getTMLTaskByName(task.getName().replace(tabName, tabName + "_" + name)), node);
map.removeTask(task);
} else {
}
}*/
//map.setTMLModeling(newmodel);
// map.setTMLModeling(newmodel);
return;
}
public void buildHSMActivityDiagram(String cpuName){
int xpos = 0;
int ypos = 0;
TGConnector fromStart;
//Build HSM Activity diagram
TMLActivityDiagramPanel tad = tmlcdp.getTMLActivityDiagramPanel("HSM_" + cpuName);
if (tad ==null){
System.out.println("Missing task ");
return;
}
TMLADStartState start = (TMLADStartState) tad.getComponentList().get(0);
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
if (hsmChannelMap.get(cpuName).size() ==0){
TMLADStopState stop = new TMLADStopState(100, 100, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(stop, 100, 100, false, true);
//Connect stop and start
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(start.getTGConnectingPointAtIndex(0));
fromStart.setP2(stop.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 100, 100, false, true);
return;
}
TMLADReadRequestArg req = new TMLADReadRequestArg(300, 100, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(req, 300, 100, false, true);
req.setParam(0, "channelIndex");
req.makeValue();
//Connect start and readrequest
fromStart.setP1(start.getTGConnectingPointAtIndex(0));
fromStart.setP2(req.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
TMLADChoice choice = new TMLADChoice(300, 200, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(choice, 300, 200, false, true);
//Connect readrequest and choice
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(req.getTGConnectingPointAtIndex(1));
fromStart.setP2(choice.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
int xc = 150;
//Allows 9 channels max to simplify the diagram
//If more than 3 channels, build 2 levels of choices
if (hsmChannelMap.get(cpuName).size() > 3) {
TMLADChoice choice2 = new TMLADChoice(xc, 400, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
int i = 0;
for (HSMChannel ch : hsmChannelMap.get(cpuName)) {
if (i>8){
break;
}
if (i % 3 == 0) {
//Add a new choice every third channel
choice2 = new TMLADChoice(xc, 250, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(choice2, xc, 400, false, true);
//Connect new choice operator to top choice fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(choice.getTGConnectingPointAtIndex(i / 3 + 1));
fromStart.setP2(choice2.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
}
TMLADReadChannel rd = new TMLADReadChannel(xc, 300, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
rd.setChannelName("data_" + ch.name + "_" + ch.task);
rd.setSecurityContext(channelSecMap.get(ch.name));
tad.addComponent(rd, xc, 300, false, true);
//Connect choice and readchannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(choice2.getTGConnectingPointAtIndex(i % 3 + 1));
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
TMLADWriteChannel wr = new TMLADWriteChannel(xc, 600, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr.setChannelName("retData_" + ch.name + "_" + ch.task);
tad.addComponent(wr, xc, 600, false, true);
wr.setSecurityContext(channelSecMap.get(ch.name));
if (ch.secType == HSMChannel.DEC) {
TMLADDecrypt dec = new TMLADDecrypt(xc, 500, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
dec.securityContext = channelSecMap.get(ch.name);
tad.addComponent(dec, xc, 500, false, true);
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
fromStart.setP2(dec.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
fromStart.setP2(dec.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Connect encrypt and writechannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(dec.getTGConnectingPointAtIndex(1));
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
} else {
TMLADEncrypt enc = new TMLADEncrypt(xc, 500, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
enc.securityContext = channelSecMap.get(ch.name);
if (ch.secType == HSMChannel.SENC) {
enc.type = "Symmetric Encryption";
} else if (ch.secType == HSMChannel.AENC) {
enc.type = "Asymmetric Encryption";
} else if (ch.secType == HSMChannel.MAC) {
enc.type = "MAC";
} else if (ch.secType == HSMChannel.NONCE) {
enc.type = "Nonce";
}
enc.message_overhead = overhead;
enc.encTime = encComp;
enc.decTime = decComp;
enc.nonce = ch.nonceName;
tad.addComponent(enc, xc, 500, false, true);
//Connect encrypt and readchannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
fromStart.setP2(enc.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Connect encrypt and writechannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(enc.getTGConnectingPointAtIndex(1));
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Add Stop
TMLADStopState stop = new TMLADStopState(xc, 600, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(stop, xc, 700, false, true);
//Connext stop and write channel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
fromStart.setP2(stop.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
}
xc += 300;
i++;
}
} else {
int i = 1;
for (HSMChannel ch : hsmChannelMap.get(cpuName)) {
//Add guard as channelindex
choice.setGuard("[channelIndex=="+channelIndexMap.get(ch.name)+"]",i-1);
TMLADReadChannel rd = new TMLADReadChannel(xc, 300, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
rd.setChannelName("data_" + ch.name + "_" + ch.task);
rd.setSecurityContext(channelSecMap.get(ch.name));
tad.addComponent(rd, xc, 300, false, true);
//Recieve plaintext data if encrypting
if (ch.secType != HSMChannel.DEC) {
rd.setEncForm(false);
}
//Connect choice and readchannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(choice.getTGConnectingPointAtIndex(i));
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, xc, 300, false, true);
fromStart = new TGConnectorTMLAD(xc, 350, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
//If needed, receive nonce from task
if (!ch.nonceName.equals("")){
tad.addComponent(fromStart, 300, 200, false, true);
rd = new TMLADReadChannel(xc, 350, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
rd.setChannelName("data_" + ch.name + "_" + ch.task);
rd.setSecurityContext(ch.nonceName);
tad.addComponent(rd, xc, 350, false, true);
fromStart.setP2(rd.getTGConnectingPointAtIndex(0));
fromStart = new TGConnectorTMLAD(xc, 350, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
}
//Send data back to task
TMLADWriteChannel wr = new TMLADWriteChannel(xc, 600, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
wr.setChannelName("retData_" + ch.name + "_" + ch.task);
//Return plaintext data if decrypting
if (ch.secType == HSMChannel.DEC) {
wr.setEncForm(false);
}
tad.addComponent(wr, xc, 600, false, true);
wr.setSecurityContext(channelSecMap.get(ch.name));
if (ch.secType == HSMChannel.DEC) {
//Add Decrypt operator
TMLADDecrypt dec = new TMLADDecrypt(xc, 500, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
dec.securityContext = channelSecMap.get(ch.name);
tad.addComponent(dec, xc, 500, false, true);
//Connect decrypt and readchannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
fromStart.setP2(dec.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Connect encrypt and writechannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(dec.getTGConnectingPointAtIndex(1));
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Add Stop
TMLADStopState stop = new TMLADStopState(xc, 700, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(stop, xc, 700, false, true);
//Connect stop and write channel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
fromStart.setP2(stop.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
} else {
TMLADEncrypt enc = new TMLADEncrypt(xc, 500, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
enc.securityContext = channelSecMap.get(ch.name);
if (ch.secType == HSMChannel.SENC) {
enc.type = "Symmetric Encryption";
} else if (ch.secType == HSMChannel.AENC) {
enc.type = "Asymmetric Encryption";
} else if (ch.secType == HSMChannel.MAC) {
enc.type = "MAC";
} else if (ch.secType == HSMChannel.NONCE) {
enc.type = "Nonce";
}
enc.message_overhead = overhead;
enc.encTime = encComp;
enc.decTime = decComp;
tad.addComponent(enc, xc, 500, false, true);
//Connect encrypt and readchannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(rd.getTGConnectingPointAtIndex(1));
fromStart.setP2(enc.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Connect encrypt and writechannel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(enc.getTGConnectingPointAtIndex(1));
fromStart.setP2(wr.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
//Add Stop TMLADStopState stop = new TMLADStopState(xc, 700, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad);
tad.addComponent(stop, xc, 700, false, true);
//Connect stop and write channel
fromStart = new TGConnectorTMLAD(xpos, ypos, tad.getMinX(), tad.getMaxX(), tad.getMinY(), tad.getMaxY(), false, null, tad, null, null, new Vector<Point>());
fromStart.setP1(wr.getTGConnectingPointAtIndex(1));
fromStart.setP2(stop.getTGConnectingPointAtIndex(0));
tad.addComponent(fromStart, 300, 200, false, true);
}
xc += 300;
i++;
}
}
}
class HSMChannel {
public String name;
public static final int SENC = 0;
public static final int NONCE_ENC = 1;
public static final int MAC = 2;
public static final int DEC = 3;
public static final int AENC = 4;
public static final int NONCE = 5;
public String task;
public String securityContext = "";
public int secType;
public String nonceName = "";
public HSMChannel(String n, String t, int type) {
name = n;
task = t;
secType = type;
}
}
class ChannelData {
public String name;
public boolean isOrigin;
public boolean isChan;
public ChannelData(String n, boolean orig, boolean isCh) {
name = n;
isOrigin = orig;
isChan = isCh;
}
}
}