diff --git a/assignments/src/MV3500Cohort2021JulySeptember/projects/AllenReynolds/KineticFirewallSimulationProgramAllenReynolds.java b/assignments/src/MV3500Cohort2021JulySeptember/projects/AllenReynolds/KineticFirewallSimulationProgramAllenReynolds.java
new file mode 100644
index 0000000000000000000000000000000000000000..1daf2242f1956189a40b2f330f863a90dd38bdd8
--- /dev/null
+++ b/assignments/src/MV3500Cohort2021JulySeptember/projects/AllenReynolds/KineticFirewallSimulationProgramAllenReynolds.java
@@ -0,0 +1,565 @@
+/**
+ * Copyright (c) 2008-2021, MOVES Institute, Naval Postgraduate School (NPS). All rights reserved.
+ * This work is provided under a BSD open-source license, see project license.html and license.txt
+ *
+ * This Program is a modified version of ExampleSimulationProgram in order to see the
+ * verbose plain text pdu log. This simulates a firewall identifying a malicious packet
+ * and tracing its source before destroying it - updated September 12, 2021 to ensure
+ * correct file pushed to Gitlab.
+ *
+ * @author snapp
+ */
+package MV3500Cohort2021JulySeptember.projects.AllenReynolds;
+
+import edu.nps.moves.dis7.enumerations.*; // match any
+import edu.nps.moves.dis7.pdus.*; // match any of the PDU classes, easier than listing individually
+import edu.nps.moves.dis7.utilities.DisThreadedNetworkInterface;
+import edu.nps.moves.dis7.utilities.PduFactory;
+import edu.nps.moves.dis7.utilities.stream.PduRecorder;
+import java.util.ArrayList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * The purpose of this program is to provide an easily modifiable example
+ * simulation program that includes DIS-capable entities doing tasks and
+ * reporting them to the network. Default settings include PDU recording turned
+ * on by default.
+ */
+public class KineticFirewallSimulationProgramAllenReynolds {
+
+ private boolean verboseComments = true;
+ static final String NETWORK_ADDRESS_DEFAULT = "239.1.2.3";
+ static final int NETWORK_PORT_DEFAULT = 3000;
+ static String networkAddress = NETWORK_ADDRESS_DEFAULT;
+ static int networkPort = NETWORK_PORT_DEFAULT;
+ String DEFAULT_OUTPUT_DIRECTORY = "./pduLog";
+
+ private EntityID createFriendFireWall() {
+ EntityID FNFireWallID = new EntityID(); // 1.1.225.1.1.1 Platform,Cyber,USA,FireWall
+ FNFireWallID.setSiteID(13);
+ FNFireWallID.setApplicationID(43);
+ FNFireWallID.setEntityID(103);
+ return FNFireWallID;
+ }
+
+ private EntityType createFriendFireWallType() {
+ EntityType FNFireWallType = new EntityType();
+ FNFireWallType.setEntityKind(EntityKind.PLATFORM);
+ FNFireWallType.setDomain(Domain.inst(PlatformDomain.OTHER));
+ FNFireWallType.setCountry(Country.UNITED_STATES_OF_AMERICA_USA);
+ FNFireWallType.setCategory(3);
+ FNFireWallType.setSubCategory(1);
+ FNFireWallType.setSpecific(1);
+ return FNFireWallType;
+ }
+
+ private EntityID createMalPacket() {
+ EntityID MalPacketID = new EntityID(); // 1.1.45.1.7.1 Platform,Cyber,China,MaliciousPacket
+ MalPacketID.setSiteID(66);
+ MalPacketID.setApplicationID(666);
+ MalPacketID.setEntityID(6666);
+ return MalPacketID;
+ }
+
+ private EntityType createMalPacketType() {
+ EntityType MalPacketType = new EntityType();
+ MalPacketType.setEntityKind(EntityKind.PLATFORM);
+ MalPacketType.setDomain(Domain.inst(PlatformDomain.OTHER));
+ MalPacketType.setCountry(Country.CHINA_PEOPLES_REPUBLIC_OF_CHN);
+ MalPacketType.setCategory(3);
+ MalPacketType.setSubCategory(1);
+ MalPacketType.setSpecific(1);
+ return MalPacketType;
+ }
+
+ private EntityID createFriendPacket() {
+ EntityID FNPacketID = new EntityID(); // 1.1.225.1.1.1 Platform,Cyber,JPN,FriendPacket
+ FNPacketID.setSiteID(14);
+ FNPacketID.setApplicationID(44);
+ FNPacketID.setEntityID(104);
+ return FNPacketID;
+ }
+
+ private EntityType createFriendPacketType() {
+ EntityType FNFireWallType = new EntityType();
+ FNFireWallType.setEntityKind(EntityKind.PLATFORM);
+ FNFireWallType.setDomain(Domain.inst(PlatformDomain.OTHER));
+ FNFireWallType.setCountry(Country.JAPAN_JPN);
+ FNFireWallType.setCategory(3);
+ FNFireWallType.setSubCategory(1);
+ FNFireWallType.setSpecific(1);
+ return FNFireWallType;
+ }
+
+ private MunitionDescriptor createTraceroute() {
+
+ EntityType TracerouteType = new EntityType(); //2.2.225.2.13.1
+ TracerouteType.setEntityKind(EntityKind.MUNITION);
+ TracerouteType.setDomain(Domain.inst(PlatformDomain.OTHER));
+ TracerouteType.setCountry(Country.UNITED_STATES_OF_AMERICA_USA);
+ TracerouteType.setCategory(2);
+ TracerouteType.setSubCategory(8);
+ TracerouteType.setSpecific(1);
+ MunitionDescriptor Traceroute = new MunitionDescriptor();
+ Traceroute.setMunitionType(TracerouteType);
+ Traceroute.setQuantity(1000);
+ Traceroute.setFuse(MunitionDescriptorFuse.CONTACT);
+ Traceroute.setRate(200);
+ return Traceroute;
+ }
+
+ /**
+ * This runSimulationLoops() method is for you, a programmer-modifiable
+ * method for defining and running a new simulation of interest. Welcome!
+ * Other parts of this program handle bookkeeping and plumbing tasks so that
+ * you can focus on your model entities and activities. Expandable support
+ * includes DIS EntityStatePdu, FirePdu and CommentPdu all available for
+ * modification and sending in a simulation loop. Continuous improvement
+ * efforts seek to make this program as easy and straightforward as possible
+ * for DIS simulationists to use and adapt. All of the other methods are
+ * setup, teardown and configuration that you may find interesting, even
+ * helpful, but don't really have to worry about.
+ */
+ @SuppressWarnings("SleepWhileInLoop") // yes we do that
+ public void runSimulationLoops() {
+ try {
+ /**
+ * seconds for real-time execution (not simulation time, which may
+ * or may not be the same)
+ */
+ final double SIMULATION_LOOP_DURATION_SECONDS = 1.0;
+ final int SIMULATION_MAX_LOOP_COUNT = 10; // be deliberate out out there! also avoid infinite loops.
+ int simulationLoopCount = 0; // variable, initialized at 0
+ boolean simulationComplete = false; // sentinel variable as termination condition,, are we done yet?
+ boolean fireBool = false;
+ boolean destBool = false;
+
+ // TODO reset clock to zero each time for consistent outputs
+ // Your model setup: define participants. who's who in this zoo?
+ // Assuming you keep track of entity objects... here is some support for for Entity 1.
+ // create PDU object for US Firewall and set its values.
+ EntityStatePdu entityStatePdu_1 = pduFactory.makeEntityStatePdu();
+ entityStatePdu_1.setEntityID(createFriendFireWall());
+ entityStatePdu_1.setEntityType(createFriendFireWallType());
+ entityStatePdu_1.getEntityLocation().setX(0);
+ entityStatePdu_1.setForceId(ForceID.FRIENDLY);
+
+ // TODO someday, use enumerations; is there a unique site triplet for MOVES Institute?
+ // create PDU object for Malware Packet and set its values.
+ EntityStatePdu entityStatePdu_2 = pduFactory.makeEntityStatePdu();
+ entityStatePdu_2.setEntityID(createMalPacket());
+ entityStatePdu_2.setEntityType(createMalPacketType());
+ entityStatePdu_2.getEntityLocation().setX(7);
+ entityStatePdu_2.setForceId(ForceID.OPPOSING);
+
+ // create PDU object for Friendly Packet and set its values.
+ EntityStatePdu entityStatePdu_3 = pduFactory.makeEntityStatePdu();
+ entityStatePdu_3.setEntityID(createFriendPacket());
+ entityStatePdu_3.setEntityType(createFriendPacketType());
+ entityStatePdu_3.getEntityLocation().setX(8);
+ entityStatePdu_3.setForceId(ForceID.FRIENDLY);
+
+ int MalPacketPingsReceived = 0;
+
+ FirePdu firePdu = pduFactory.makeFirePdu(); // for entity 1 first weapon (possible traceroute)
+ // should we customize this munition? what is it for your simulation?
+ EntityID fireID = new EntityID();
+ fireID.setSiteID(13);
+ fireID.setApplicationID(43);
+ fireID.setEntityID(103);
+ EntityID targetID = new EntityID();
+ targetID.setSiteID(66);
+ targetID.setApplicationID(666);
+ targetID.setEntityID(6666);
+
+ firePdu.setFiringEntityID(fireID);
+ firePdu.setTargetEntityID(targetID);
+
+ firePdu.setDescriptor(createTraceroute()); // calling create Traceroute Method
+
+ EntityID TracerouteID = new EntityID();
+ TracerouteID.setEntityID(1);
+ firePdu.setMunitionExpendibleID(TracerouteID);
+
+ //Added messages for feedback
+ CommentReliablePdu MalPacketDestroyedComment
+ = pduFactory.makeCommentReliablePdu(
+ "Malware Packet DESTROYED BY Firewall"
+ );
+ CommentReliablePdu MalPacketDetectedComment
+ = pduFactory.makeCommentReliablePdu(
+ "Firewall Detects Malware engage Traceroute"
+ );
+ CommentReliablePdu FriendPacketDetectedComment
+ = pduFactory.makeCommentReliablePdu(
+ "Firewall Detects Friendly Packet... Allowing safe passage through the Firewall"
+ );
+
+ // TODO simulation management PDUs for startup, planning to design special class support
+ //DetonationPdu detonationPdu = pduFactory.makeDetonationPdu();
+ //detonationPdu.setDescriptor(pDescriptor);
+ // loop the simulation while allowed, programmer can set additional conditions to break out and finish
+ while (simulationLoopCount < SIMULATION_MAX_LOOP_COUNT) // are we done yet?
+ {
+ simulationLoopCount++; // good practice: increment loop counter as first action in that loop
+
+ // =============================================================================================
+ // * your own simulation code starts here! *
+ // =============================================================================================
+ // are there any other variables to modify at the beginning of your loop?
+ // compute a track, update an ESPDU, whatever it is that your model is doing...
+ // Where is my entity? Insert changes in position; this sample only changes X position.
+ entityStatePdu_1.getEntityLocation().setX(entityStatePdu_1.getEntityLocation().getX()); // stationary defensive posture
+ entityStatePdu_2.getEntityLocation().setX(entityStatePdu_2.getEntityLocation().getX() - 1.0); // 1m per timestep
+ entityStatePdu_3.getEntityLocation().setX(entityStatePdu_3.getEntityLocation().getX() - 1.0); // 1m per timestep
+
+ // decide whether to fire, and then update the firePdu. Hmmm, you might want a target to shoot at!
+ Double range = entityStatePdu_2.getEntityLocation().getX();
+ System.out.println("range: " + range + " hops from our Network DMZ!");
+
+ if (range <= 5) { // Range 5
+ if (!fireBool) {
+ sendSinglePdu(MalPacketDetectedComment);
+ sendSinglePdu(FriendPacketDetectedComment);
+ }
+ fireBool = true;
+ System.out.println("Entity#"
+ + firePdu.getFiringEntityID().getEntityID()
+ + " is firing "
+ + firePdu.getDescriptor().getMunitionType().getDomain()
+ + "."
+ + firePdu.getDescriptor().getMunitionType().getCountry()
+ + "."
+ + firePdu.getDescriptor().getMunitionType().getCategory()
+ + "."
+ + firePdu.getDescriptor().getMunitionType().getSubCategory()
+ + "."
+ + firePdu.getDescriptor().getMunitionType().getSpecific()
+ + "."
+ + " at Entity#" + firePdu.getTargetEntityID().getEntityID());
+
+ if (firePdu.getTargetEntityID().getEntityID() == 6666) {
+ MalPacketPingsReceived += 1;
+ if (MalPacketPingsReceived > 1) {
+ // The Firewall destroys the MalPacket
+
+ System.out.println(
+ "Malware Packet DESTROYED BY Firewall after "
+ + MalPacketPingsReceived
+ + " pings from the traceroute."
+ );
+ narrativeMessage4 = "Destroyed MalPacket";
+ destBool = true;
+ simulationComplete = true;
+
+ }
+ }
+ }
+ // etc. etc. your code goes here for your simulation of interest
+
+ // something happens between my simulation entities, la de da de da...
+ System.out.println("\n... Firewall is scanning for incoming packets...");
+
+ // make your reports: narrative code for CommentPdu here (set all to empty strings to avoid sending)
+ narrativeMessage1 = "MV3500 KineticFirewallSimulationProgram";
+ narrativeMessage2 = "runSimulation() loop " + simulationLoopCount;
+ narrativeMessage3 = "verified PDUs for simulation!"; // intentionally blank for testing
+
+ // your loop termination condition goes here
+ if (simulationLoopCount > 4) // for example
+ {
+ simulationComplete = true;
+ }
+ // =============================================================================================
+ // * your own simulation code is finished here! *
+ // =============================================================================================
+
+ // staying synchronized with timestep: wait duration for elapsed time in this loop
+ // Thread.sleep needs a (long) parameter for milliseconds, which are clumsy to use sometimes
+ Thread.sleep((long) (SIMULATION_LOOP_DURATION_SECONDS * 1000)); // seconds * (1000 msec/sec) = milliseconds
+ System.out.println("... [Pausing for " + SIMULATION_LOOP_DURATION_SECONDS + " seconds]");
+
+ // OK now send the status PDUs for this loop, and then continue
+ System.out.println("sending PDUs for simulation step "
+ + simulationLoopCount
+ + ", monitor loopback to confirm sent"
+ );
+ sendAllPdusForLoopTimestep(
+ entityStatePdu_1, firePdu,
+ timeStepComment,
+ narrativeMessage1,
+ narrativeMessage2,
+ narrativeMessage3
+ );
+ sendSinglePdu(entityStatePdu_2); // me too i.e. 2!
+ System.out.println("... [PDUs successfully sent for this loop] \n");
+
+ // ===============================
+ // loop now finished, check whether to terminate if simulation complete, otherwise continue
+ if (simulationComplete || (simulationLoopCount > 10000)) // for example; including fail-safe condition is good
+ {
+ //sendSinglePdu(detonationPdu);
+ System.out.println("... [Termination condition met, simulationComplete = " + simulationComplete + "]"); // ", final loopCount=" + loopCount +
+ break;
+ }
+ } // end of simulation loop
+
+ narrativeMessage2 = "runSimulation() completed successfully"; // all done
+ sendCommentPdu(narrativeComment, narrativeMessage1, narrativeMessage2, narrativeMessage3);
+ System.out.println("... [final CommentPdu successfully sent for simulation]");
+ // TODO simulation management PDUs
+ } catch (InterruptedException iex) // handle any exception that your code might choose to provoke!
+ {
+ Logger.getLogger(KineticFirewallSimulationProgramAllenReynolds.class.getName()).log(Level.SEVERE, null, iex);
+ }
+ }
+ /* **************************** infrastructure code, modification is seldom needed ************************* */
+
+ String narrativeMessage1 = new String();
+ String narrativeMessage2 = new String();
+ String narrativeMessage3 = new String();
+ String narrativeMessage4 = new String();
+
+ /* VariableRecordType enumerations have potential use with CommentPdu logs */
+ /* TODO contrast to EntityType */
+ VariableRecordType descriptionComment = VariableRecordType.DESCRIPTION;
+ VariableRecordType narrativeComment = VariableRecordType.COMPLETE_EVENT_REPORT;
+ VariableRecordType statusComment = VariableRecordType.APPLICATION_STATUS;
+ VariableRecordType timeStepComment = VariableRecordType.APPLICATION_TIMESTEP;
+ VariableRecordType otherComment = VariableRecordType.OTHER;
+
+ /**
+ * Output prefix to identify this class, helps with logging
+ */
+ private final static String TRACE_PREFIX = "[" + KineticFirewallSimulationProgramAllenReynolds.class.getName() + "] ";
+
+ // class variables
+ PduFactory pduFactory = new PduFactory();
+ DisThreadedNetworkInterface disNetworkInterface;
+ DisThreadedNetworkInterface.PduListener pduListener;
+ Pdu receivedPdu;
+ PduRecorder pduRecorder;
+
+ /**
+ * Constructor design goal: additional built-in initialization conveniences
+ * can go here to keep student efforts focused on the runSimulation()
+ * method.
+ */
+ public KineticFirewallSimulationProgramAllenReynolds() {
+ // Constructor is under consideration. Constructor is not currently needed.
+ }
+
+ /**
+ * Utility Constructor that allows your example simulation program to
+ * override default network address and port
+ *
+ * @param address network address to use
+ * @param port corresponding network port to use
+ */
+ public KineticFirewallSimulationProgramAllenReynolds(String address, int port) {
+ setNetworkAddress(address);
+
+ setNetworkPort(port);
+ }
+
+ /**
+ * @return the networkAddress
+ */
+ public String getNetworkAddress() {
+ return networkAddress;
+ }
+
+ /**
+ * @param newNetworkAddress the networkAddress to set
+ */
+ public final void setNetworkAddress(String newNetworkAddress) {
+ KineticFirewallSimulationProgramAllenReynolds.networkAddress = newNetworkAddress;
+ }
+
+ /**
+ * @return the networkPort
+ */
+ public int getNetworkPort() {
+ return networkPort;
+ }
+
+ /**
+ * @param newNetworkPort the networkPort to set
+ */
+ public final void setNetworkPort(int newNetworkPort) {
+ KineticFirewallSimulationProgramAllenReynolds.networkPort = newNetworkPort;
+ }
+
+ /**
+ * Initialize network interface, choosing best available network interface
+ */
+ public void setUpNetworkInterface() {
+ disNetworkInterface = new DisThreadedNetworkInterface(getNetworkAddress(), getNetworkPort());
+ disNetworkInterface.setDescriptor("KineticFirewallSimulationProgram pdu looping");
+
+ System.out.println("Network confirmation:"
+ + " address=" + disNetworkInterface.getAddress()
+ + // disNetworkInterface.getMulticastGroup() +
+ " port=" + disNetworkInterface.getPort()); // + disNetworkInterface.getDisPort());
+ pduListener = new DisThreadedNetworkInterface.PduListener() {
+ /**
+ * Callback handler for listener
+ */
+ @Override
+ public void incomingPdu(Pdu newPdu) {
+ receivedPdu = newPdu;
+ }
+ };
+ disNetworkInterface.addListener(pduListener);
+
+ String outputDirectory = DEFAULT_OUTPUT_DIRECTORY;
+ System.out.println("Beginning pdu save to directory " + outputDirectory);
+ pduRecorder = new PduRecorder(outputDirectory, getNetworkAddress(), getNetworkPort()); // assumes save
+ pduRecorder.setDescriptor("KineticFirewallSimulationProgram pduRecorder");
+ pduRecorder.start(); // begin running
+ }
+
+ /**
+ * All done, release network resources
+ */
+ public void tearDownNetworkInterface() {
+ pduRecorder.stop();
+
+ disNetworkInterface.removeListener(pduListener);
+
+ disNetworkInterface.close();
+// disNetworkInterface.kill(); // renamed as close(), deprecated
+// disNetworkInterface = null; // making sure no possibility of zombie process remaining...
+ }
+
+ /**
+ * Send a single Protocol Data Unit (PDU) of any type
+ *
+ * @param pdu the pdu to send
+ */
+ private void sendSinglePdu(Pdu pdu) {
+ try {
+ disNetworkInterface.send(pdu);
+ Thread.sleep(100); // TODO consider refactoring the wait logic and moving externally
+ } catch (InterruptedException ex) {
+ System.err.println(this.getClass().getName() + " Error sending PDU: " + ex.getLocalizedMessage());
+ System.exit(1);
+ }
+ }
+
+ /**
+ * Send Comment PDU
+ *
+ * @see
+ * <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html">Passing
+ * Information to a Method or a Constructor</a> Arbitrary Number of
+ * Arguments
+ * @param commentType enumeration value describing purpose of the narrative
+ * comment
+ * @param comments String array of narrative comments
+ */
+ public void sendCommentPdu(VariableRecordType commentType,
+ // vararg... variable-length set of String comments can optionally follow
+ String... comments) {
+ sendAllPdusForLoopTimestep(null, null, commentType, comments);
+ }
+
+ /**
+ * Send EntityState, Fire, Comment PDUs that got updated for this loop,
+ * reflecting state of current simulation timestep.
+ *
+ * @see
+ * <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html">Passing
+ * Information to a Method or a Constructor</a> Arbitrary Number of
+ * Arguments
+ * @param entityStatePdu the ESPDU to send, if any
+ * @param firePdu the FirePDU to send, if any
+ * @param commentType enumeration value describing purpose of the narrative
+ * comment
+ * @param comments String array of narrative comments
+ */
+ public void sendAllPdusForLoopTimestep(EntityStatePdu entityStatePdu,
+ FirePdu firePdu,
+ VariableRecordType commentType,
+ // vararg... variable-length set of String comments can optionally follow
+ String... comments) {
+ if (entityStatePdu != null) {
+ sendSinglePdu(entityStatePdu);
+ }
+
+ if (firePdu != null) {
+ sendSinglePdu(firePdu); // bang
+ }
+ if ((comments != null) && (comments.length > 0)) {
+ ArrayList<String> newCommentsList = new ArrayList<>();
+ for (String comment : comments) {
+ if (!comment.isEmpty()) {
+ newCommentsList.add(comment); // OK found something to send
+ }
+ }
+ if (!newCommentsList.isEmpty()) {
+ if (commentType == null) {
+ commentType = otherComment; // fallback value otherComment
+ } // now build the commentPdu from these string inputs, thus constructing a narrative entry
+ CommentPdu commentPdu = pduFactory.makeCommentPdu(commentType, newCommentsList.toArray(new String[0])); // comments);
+ sendSinglePdu(commentPdu);
+ if (isVerboseComments()) {
+ System.out.println("*** [Narrative comment sent: " + commentType.name() + "] " + newCommentsList.toString());
+ }
+ }
+ }
+ }
+
+ /**
+ * Main method is first executed when a program instance is loaded.
+ *
+ * @see
+ * <a href="https://docs.oracle.com/javase/tutorial/getStarted/application/index.html">Java
+ * Tutorials: A Closer Look at the "Hello World!" Application</a>
+ * @param args command-line arguments are an array of optional String
+ * parameters that are passed from execution environment during invocation
+ */
+ public static void main(String[] args) {
+ System.out.println(TRACE_PREFIX + "started...");
+
+ KineticFirewallSimulationProgramAllenReynolds thisProgram = new KineticFirewallSimulationProgramAllenReynolds(); // creates instance
+
+ // initial execution: can handle args array of initialization arguments here
+ if (args.length == 2) {
+ if ((args[0] != null) && !args[0].isEmpty()) {
+ thisProgram.setNetworkAddress(args[0]);
+ }
+
+ if ((args[1] != null) && !args[1].isEmpty()) {
+ thisProgram.setNetworkPort(Integer.parseInt(args[1]));
+ }
+ } else if (args.length != 0) {
+ System.err.println("Usage: " + thisProgram.getClass().getName() + " [address port]");
+ System.exit(-1);
+ }
+ // OK here we go...
+
+ thisProgram.setUpNetworkInterface();
+
+ thisProgram.runSimulationLoops(); // ... your simulation execution code goes in there ...
+
+ thisProgram.tearDownNetworkInterface(); // make sure no processes are left lingering
+
+ System.out.println(TRACE_PREFIX + "complete."); // report successful completion
+ }
+
+ /**
+ * @return whether verboseComments mode is enabled
+ */
+ public boolean isVerboseComments() {
+ return verboseComments;
+ }
+
+ /**
+ * @param newVerboseComments whether verboseComments mode is enabled
+ */
+ public void setVerboseComments(boolean newVerboseComments) {
+ this.verboseComments = newVerboseComments;
+ }
+}