use of verdict.vdm.vdm_lustre.ContractSpec in project VERDICT by ge-high-assurance.
the class VDMInstrumentor method dec_var_asmp_const.
/*
* Declare and Define weak assumptions for the blame assignment.
*/
protected void dec_var_asmp_const(Map<String, List<String>> connection_comp_map, boolean blame_assignment, boolean link_level) {
Set<String> vars = connection_comp_map.keySet();
List<SymbolDefinition> vars_dec = new ArrayList<SymbolDefinition>();
// String default_var = null;
Set<String> var_links = new HashSet<String>();
for (String var : vars) {
// Declaration global variables for instrumented links.
List<String> connections = connection_comp_map.get(var);
String id = var.replace("::", "_double_colon_");
SymbolDefinition var_dec = add_vars_assume(id, connections);
if (!connections.isEmpty()) {
vars_dec.add(var_dec);
var_links.addAll(connections);
}
}
String[] vars_assumption = new String[vars.size()];
vars_assumption = vars.toArray(vars_assumption);
Expression assume_expr = null;
if (link_level) {
String[] links = new String[var_links.size()];
links = var_links.toArray(links);
assume_expr = add_assume_amo(links);
} else {
assume_expr = add_assume_amo(vars_assumption);
}
// Adding Xor assumption for components.
ComponentImpl compImpl = retrieve_main_cmp_impl();
if (compImpl != null) {
if (compImpl.getBlockImpl() == null) {
compImpl = retrieve_block_impl(compImpl);
}
ContractSpec contractSpec = compImpl.getType().getContract();
ContractItem assume_item = new ContractItem();
if (assume_expr != null) {
assume_item.setExpression(assume_expr);
contractSpec.getAssume().add(assume_item);
}
if (blame_assignment == false && contractSpec != null) {
contractSpec.getSymbol().addAll(vars_dec);
}
}
}
use of verdict.vdm.vdm_lustre.ContractSpec in project VERDICT by ge-high-assurance.
the class VDMInstrumentor method instrument_link.
// public void instrument_link(Connection connection) {
// // Connection Source
// ConnectionEnd src = connection.getSource();
//
// // Connection Destination
// ConnectionEnd dest = connection.getDestination();
//
// // Source Component
// Port src_port = src.getComponentPort();
// // Destination Component
// Port dest_port = dest.getComponentPort();
//
// if (src_port == null && dest_port == null) {
// // Both are sub-compon
// System.out.println("Both are subcomponents.");
// }
// if (src_port == null && dest_port != null) {
// // Only one is Subcomponent
// System.out.println(dest_port.getId() + " -- " + dest_port.getName());
// }
// if (src_port != null && dest_port == null) {
// // One Subcomponent
// System.out.println(src_port.getId() + " -- " + src_port.getName());
// }
// }
// public void create_link(Connection old_channel, ComponentInstance
// src_componentInstance,
// ComponentInstance dest_componentInstance) {
//
// ComponentInstance instrumented_componentInstance = new ComponentInstance();
//
// String component_ID = src_componentInstance.getName() + "_Inst_" +
// dest_componentInstance.getName();
// instrumented_componentInstance.setId(component_ID + "_Instance");
// instrumented_componentInstance.setName(component_ID);
//
// instrumented_componentInstance.setSpecification(value);
// instrumented_componentInstance.setImplementation(value);
//
// ComponentType instrumented_component = new ComponentType();
// instrumented_component.setId(component_ID);
// instrumented_component.setName(component_ID);
//
//
//
// Connection inst_channel = new Connection();
//
// //Update Old connection Destination
// old_channel.setDestination(value);
//
// //Add New Connection Source
// inst_channel.setSource(value);
// //Add New Connection Destination
// inst_channel.setDestination(value);
//
//
// }
public String instrument_link(String compID, Connection connection, BlockImpl blockImpl) {
// instrument_link(connection);
// System.out.println("Instrumented Link ***" + connection.getName());
// Default Block Implementation
ComponentImpl compImpl = null;
if (compID != null) {
compImpl = retrieve_cmp_impl(compID);
}
// Connections without Components Instrumentation.
if (compImpl == null) {
compImpl = retrieve_main_cmp_impl();
}
ComponentType instrumented_cmp = new ComponentType();
// R.H.S
ConnectionEnd src = connection.getSource();
ComponentInstance src_componentInstance = new ComponentInstance();
// Source Connection
Port src_port = src.getComponentPort();
if (src_port != null) {
String identifier = compImpl.getId();
// identifier = identifier.replace(".I", "_I");
identifier = identifier.replace(".", "_dot_");
identifier = identifier.replace("::", "_double_colon_");
src_componentInstance.setId(identifier);
src_componentInstance.setName(identifier);
src_componentInstance.setImplementation(compImpl);
}
// if (src_port == instrumented_port) {
CompInstancePort compInstancePort = src.getSubcomponentPort();
if (compInstancePort != null) {
src_componentInstance = compInstancePort.getSubcomponent();
src_port = compInstancePort.getPort();
}
// R.H.S
ConnectionEnd dest = connection.getDestination();
ComponentInstance dest_componentInstance = new ComponentInstance();
// Source Connection
Port dest_port = dest.getComponentPort();
if (dest_port != null) {
String identifier = compImpl.getId();
// identifier = identifier.replace(".I", "_I");
identifier = identifier.replace(".", "_dot_");
identifier = identifier.replace("::", "_double_colon_");
dest_componentInstance.setId(identifier);
dest_componentInstance.setName(identifier);
dest_componentInstance.setImplementation(compImpl);
}
// if (dest_port == instrumented_port) {
compInstancePort = dest.getSubcomponentPort();
if (compInstancePort != null) {
dest_componentInstance = compInstancePort.getSubcomponent();
dest_port = compInstancePort.getPort();
}
String instrument_cmp_Id = src_componentInstance.getName() + "_Inst_" + dest_componentInstance.getName() + "_port_" + dest_port.getName();
instrument_cmp_Id = instrument_cmp_Id.replace(".", "_dot_");
// Setting Component IDs
instrumented_cmp.setId(instrument_cmp_Id);
instrumented_cmp.setName(instrument_cmp_Id);
// output port
Port instrumented_port_dest = new Port();
instrumented_port_dest.setId(dest_port.getId());
instrumented_port_dest.setName(dest_port.getName());
instrumented_port_dest.setMode(dest_port.getMode());
instrumented_port_dest.setType(dest_port.getType());
if (dest_port.isEvent() != null && dest_port.isEvent()) {
instrumented_port_dest.setEvent(true);
} else {
instrumented_port_dest.setEvent(false);
}
instrumented_cmp.getPort().add(instrumented_port_dest);
// Input port
Port instrumented_port_src = new Port();
instrumented_port_src.setId(src_port.getId());
instrumented_port_src.setName(src_componentInstance + "_port_" + src_port.getName());
instrumented_port_src.setMode(src_port.getMode());
if (src_port.isEvent() != null && src_port.isEvent()) {
instrumented_port_src.setEvent(true);
} else {
instrumented_port_src.setEvent(false);
}
String global_constant_Id = src_componentInstance.getName();
if (instrumented_port_src.getMode() == instrumented_port_dest.getMode()) {
instrumented_port_src.setName(src_port.getName());
if (instrumented_port_src.getMode() == PortMode.IN) {
instrumented_port_src.setMode(PortMode.OUT);
} else {
instrumented_port_dest.setMode(PortMode.IN);
}
} else {
instrumented_port_src.setName(src_port.getName());
}
if (dest_port.getMode() == PortMode.OUT) {
global_constant_Id += "_port_" + dest_port.getName() + "_instrumented";
} else {
global_constant_Id += "_port_" + src_port.getName() + "_instrumented";
}
instrumented_port_src.setType(dest_port.getType());
instrumented_cmp.getPort().add(instrumented_port_src);
vdm_model.getComponentType().add(instrumented_cmp);
// Modify connection.
ConnectionEnd con_end_inst = new ConnectionEnd();
// instrumentd_port.setPort(value);
ComponentInstance instrumented_compInstance = new ComponentInstance();
instrumented_compInstance.setId(connection.getName());
instrumented_compInstance.setName(connection.getName());
instrumented_compInstance.setSpecification(instrumented_cmp);
// -----------------------------------------
// Adding Auxiliary Node.
NodeCall nodeCall = new NodeCall();
nodeCall.setNodeId(instrumented_cmp.getId());
Expression callExpr = new Expression();
callExpr.setCall(nodeCall);
ContractItem true_guarantee_item = new ContractItem();
// true_guarantee_item.setName("true");
Expression true_expr = new Expression();
Boolean true_lit = Boolean.TRUE;
true_expr.setBoolLiteral(true_lit);
true_guarantee_item.setExpression(true_expr);
ContractSpec contractSpec = new ContractSpec();
contractSpec.getGuarantee().add(true_guarantee_item);
// ---------------------------------------------
ComponentImpl instrument_compImpl = new ComponentImpl();
instrument_compImpl.setId(instrumented_cmp.getId() + "_dot_impl");
instrument_compImpl.setName(instrumented_cmp.getName() + "_dot_Impl");
instrument_compImpl.setType(instrumented_cmp);
IfThenElse ifelse = new IfThenElse();
// Condition
Expression cond_expr = new Expression();
global_constant_Id = global_constant_Id.replace(".", "_dot_");
cond_expr.setIdentifier(global_constant_Id);
ifelse.setCondition(cond_expr);
// Then
Expression then_arg = new Expression();
then_arg.setIdentifier(dest_port.getName());
ifelse.setThenBranch(callExpr);
// Else
Expression else_arg = new Expression();
else_arg.setIdentifier(dest_port.getName());
nodeCall.getArgument().add(else_arg);
ifelse.setElseBranch(then_arg);
Expression instrumented_expr = new Expression();
instrumented_expr.setConditionalExpression(ifelse);
NodeEquation n_eq = new NodeEquation();
NodeEquationLHS neq_lhs = new NodeEquationLHS();
neq_lhs.getIdentifier().add(src_port.getName() + "_instrumented");
n_eq.setLhs(neq_lhs);
n_eq.setRhs(instrumented_expr);
NodeBody nodeBody = new NodeBody();
// VariableDeclaration cond_var = new VariableDeclaration();
// cond_var.setName(gloabal_constant_Id);
// DataType dataType = new DataType();
// dataType.setPlainType(PlainType.BOOL);
// cond_var.setDataType(dataType);
// nodeBody.getVariableDeclaration().add(cond_var);
nodeBody.setIsMain(false);
nodeBody.getEquation().add(n_eq);
instrument_compImpl.setDataflowImpl(nodeBody);
instrumented_compInstance.setImplementation(instrument_compImpl);
vdm_model.getComponentImpl().add(instrument_compImpl);
vdm_model.getComponentType().add(instrumented_cmp);
// -----------------------------------------
CompInstancePort compInstance_inst_port = new CompInstancePort();
compInstance_inst_port.setPort(dest_port);
compInstance_inst_port.setSubcomponent(instrumented_compInstance);
con_end_inst.setSubcomponentPort(compInstance_inst_port);
blockImpl.getSubcomponent().add(instrumented_compInstance);
connection.setDestination(con_end_inst);
Connection new_con = new Connection();
// Copying connection related artifacts
new_con.setName(connection.getName() + "_instrumented_channel");
// new_con.setConnType(connection.getConnType());
// new_con.setFlowType(connection.getFlowType());
//
// new_con.setDataEncrypted(connection.isEncryptedTransmission());
// new_con.setAuthenticated(connection.isAuthenticated());
new_con.setSource(con_end_inst);
compInstance_inst_port.setPort(src_port);
new_con.setDestination(dest);
blockImpl.getConnection().add(new_con);
return global_constant_Id;
}
use of verdict.vdm.vdm_lustre.ContractSpec in project VERDICT by ge-high-assurance.
the class VDMInstrumentor method retrieve_component_and_channels.
protected void retrieve_component_and_channels(Model vdm_model, List<String> threats, boolean blame_assignment, boolean component_level) {
HashSet<ComponentType> vdm_components = new HashSet<ComponentType>();
HashSet<Connection> vdm_links = new HashSet<Connection>();
// Initialize Components with Empty Ports and Ignore
identifyEmptyOutputComponents();
// Initialize DataFlow for empty Implementations.
LustreProgram lt = vdm_model.getDataflowCode();
if (lt == null) {
lt = new LustreProgram();
vdm_model.setDataflowCode(lt);
}
if (threats.contains("LS")) {
System.out.println("Location Spoofing Instrumentation");
locationSpoofing(vdm_components);
}
if (threats.contains("LB")) {
System.out.println("Logic Bomb Instrumentation");
logicBomb(vdm_components);
}
if (threats.contains("SV")) {
System.out.println("Software Virus/malware/worm/trojan");
softwareVirus(vdm_components);
}
if (threats.contains("RI")) {
System.out.println("Remote Code Injection");
remoteCodeInjection(vdm_components);
}
if (threats.contains("OT")) {
System.out.println("Outsider Threat");
outsiderThreat(vdm_components);
}
if (threats.contains("IT")) {
System.out.println("Insider Threat");
insiderThreat(vdm_components);
}
if (threats.contains("HT")) {
System.out.println("Hardware Trojans");
hardwareTrojan(vdm_components);
}
if (threats.contains("NI")) {
System.out.println("Network Injection Instrumentation");
// Snooze links for component level blame assignment.
if (!component_level) {
networkInjection(vdm_links);
}
}
if (threats.contains("BN")) {
System.out.println("Benign");
vdm_components.clear();
vdm_links.clear();
}
// int component_index = 1;
// Removed Once component Implemtation assumption.
ComponentImpl componentImpl = retrieve_main_cmp_impl();
BlockImpl blockImpl = null;
if (componentImpl != null) {
blockImpl = componentImpl.getBlockImpl();
}
Map<String, HashSet<Connection>> components_map = new HashMap<String, HashSet<Connection>>();
if (vdm_components.size() > 0) {
for (ComponentType component : vdm_components) {
blockImpl = retrieve_block(component);
HashSet<Connection> vdm_cmp_links = instrument_component(component, blockImpl);
for (Connection link_con : vdm_cmp_links) {
// Check if connection contains Empty Component on Port Ends.
if (!ignoreMarkedLink(link_con)) {
// Check if Port is Probe Port
if (!isProbePort(link_con)) {
vdm_links.add(link_con);
}
}
}
components_map.put(component.getId(), vdm_cmp_links);
}
}
// Snoorzing probe ports and Empty output components
if (vdm_links.size() > 0) {
Iterator<Connection> it = vdm_links.iterator();
while (it.hasNext()) {
Connection con = it.next();
if (isProbePort(con)) {
it.remove();
} else if (ignoreMarkedLink(con)) {
it.remove();
}
}
}
HashSet<String> global_constants = new HashSet<String>();
Map<Connection, String> connections_map = new HashMap<Connection, String>();
if (vdm_links.size() > 0) {
for (Connection connection : vdm_links) {
// System.out.println("(" + connection_index++ + ") " +
// connection.getName());
// instrument_link(connection, blockImpl);
String cmpID = getComponentID(components_map, connection);
if (cmpID != null) {
// Find Block based on Connection
blockImpl = getBlockID(cmpID);
String constant = instrument_link(cmpID, connection, blockImpl);
global_constants.add(constant);
connections_map.put(connection, constant);
} else {
// Handle 'NI' as Special Case.
ConnectionEnd conDest = connection.getSource();
Port dest_port = conDest.getComponentPort();
if (dest_port != null) {
cmpID = dest_port.getId();
} else {
CompInstancePort compInstance = conDest.getSubcomponentPort();
ComponentInstance compInst = compInstance.getSubcomponent();
cmpID = compInst.getId();
}
blockImpl = retrieve_block(connection);
String constant = instrument_link(cmpID, connection, blockImpl);
global_constants.add(constant);
connections_map.put(connection, constant);
}
}
} else {
emptySelection = true;
}
// Declare Global Constants
for (String comp_id : global_constants) {
ConstantDeclaration global_comp_const = new ConstantDeclaration();
DataType global_comp_dataType = new DataType();
global_comp_dataType.setPlainType(PlainType.BOOL);
global_comp_const.setName(comp_id);
global_comp_const.setDataType(global_comp_dataType);
// Expression global_expr = new Expression();
// global_expr.setBoolLiteral(true);
// global_comp_const.setDefinition(global_expr);
vdm_model.getDataflowCode().getConstantDeclaration().add(global_comp_const);
// g_constants.add(global_comp_const);
}
Map<String, List<String>> connection_gps_comp_map = connection_gps_mapper(connections_map, components_map);
// Choosing Blame options
if (threats.contains("LS") && component_level) {
// Link Level Instrumentation varibales
dec_var_asmp_const(connection_gps_comp_map, blame_assignment, false);
} else if (threats.contains("LS") && !component_level) {
dec_var_asmp_const(connection_gps_comp_map, blame_assignment, true);
}
if (blame_assignment && component_level) {
Map<String, List<String>> connection_comp_map = connection_mapper(connections_map, components_map);
ComponentImpl compImpl = retrieve_main_cmp_impl();
// if (compImpl.getBlockImpl() == null) {
// compImpl = retrieve_block(compImpl);
// }
ContractSpec contractSpec = compImpl.getType().getContract();
for (String key : components_map.keySet()) {
String id = key.replace("::", "_double_colon_");
Expression wk_expr = new Expression();
wk_expr.setIdentifier(id);
Expression not_wkexpr = new Expression();
not_wkexpr.setNot(wk_expr);
// Adding weakly assume variables
ContractItem weakly_assume_item = new ContractItem();
weakly_assume_item.setName(id + " is not instrumented");
weakly_assume_item.setExpression(not_wkexpr);
// Checking connection before adding assumption
HashSet<Connection> empty_connection_check = components_map.get(key);
if (empty_connection_check.size() > 0) {
contractSpec.getWeaklyassume().add(weakly_assume_item);
}
}
dec_var_const(connection_comp_map);
} else if (blame_assignment && !component_level) {
ComponentImpl compImpl = retrieve_main_cmp_impl();
if (compImpl != null) {
// if (compImpl.getBlockImpl() == null) {
// compImpl = retrieve_block_impl(compImpl);
// }
ContractSpec contractSpec = compImpl.getType().getContract();
for (String key : global_constants) {
Expression wk_expr = new Expression();
wk_expr.setIdentifier(key);
Expression not_wkexpr = new Expression();
not_wkexpr.setNot(wk_expr);
// Adding weakly assume variables
ContractItem weakly_assume_item = new ContractItem();
weakly_assume_item.setName(link_name(key) + " is not instrumented");
weakly_assume_item.setExpression(not_wkexpr);
contractSpec.getWeaklyassume().add(weakly_assume_item);
}
}
}
}
use of verdict.vdm.vdm_lustre.ContractSpec in project VERDICT by ge-high-assurance.
the class VerdictLustreListener method exitInlineContract.
/**
* Extract an inline contract spec.
*/
@Override
public void exitInlineContract(LustreParser.InlineContractContext ctx) {
ctx.spec = new ContractSpec();
ctx.symbol().forEach(symbol -> ctx.spec.getSymbol().add(symbol.def));
ctx.assume().forEach(assume -> ctx.spec.getAssume().add(assume.item));
ctx.guarantee().forEach(guarantee -> ctx.spec.getGuarantee().add(guarantee.item));
ctx.contractMode().forEach(contractMode -> ctx.spec.getMode().add(contractMode.mode));
ctx.contractImport().forEach(contractImport -> ctx.spec.getImport().add(contractImport.imprt));
}
use of verdict.vdm.vdm_lustre.ContractSpec in project VERDICT by ge-high-assurance.
the class VDMInstrumentor method dec_var_const.
protected void dec_var_const(Map<String, List<String>> connection_comp_map) {
Set<String> vars = connection_comp_map.keySet();
List<SymbolDefinition> vars_dec = new ArrayList<SymbolDefinition>();
for (String var : vars) {
// Declaration global variables for instrumented links.
List<String> connections = connection_comp_map.get(var);
String id = var.replace("::", "_double_colon_");
SymbolDefinition var_dec = add_vars_assume(id, connections);
vars_dec.add(var_dec);
}
ComponentImpl compImpl = retrieve_main_cmp_impl();
// if (compImpl.getBlockImpl() == null) {
compImpl = retrieve_block_impl(compImpl);
// }
ContractSpec contractSpec = compImpl.getType().getContract();
contractSpec.getSymbol().addAll(vars_dec);
}
Aggregations