Major revamp of FlowPatternFinder to ensure thread safety. Added generic structure for comparison code which should allow for easy plugin of more sophisticated comparison algorithm later on.

Move retransmission checks to Conversation class.

Add getPackets to Conversation's API.

Extract Conversation to separate file (i.e. it is no longer an inner class). Add List of associated packets to Conversation class. Add Javadoc. Reformat variable names to match android convetions (indicating member variables by prefixing these with 'm').

Adding pcap files for remote ON and remote ON charging cases.

Adding combined PCAP (local and remote) to test out the algorithm- it successfully detects the only pattern specified in the FlowPattern class.

Separating pattern collection and analysis into 2 different threads.

Making retransmission check O(1) using HashSet/Set.

Refactoring and restructuring - Adding DnsMap class

Filter out retransmissions when reconstructing TCP flows. Now able to detect all local ON events in wlan1.local.dns.pcap.

Update pcap4j to v2.0.0-alpha to get access to packet timestamps (and possibly TCP session reassembly at a later stage). Now prints the timestamp for the occurrence of a complete match in the trace.

1) Skip zero-payload packets when reassemlbing conversations from individual packets. 2) Hardcode TP-Link Local ON pattern. 3) Rushed implementation that finds complete matches of the pattern.

First small step towards pattern search: separate packets related to packet into separate lists, one list for each conversation/session.

Converted IP to hostname map from Map<String,List<String>> to Map<String,Set<String>> to prevent multiple entries of the same hostname showing up for the same IP. Added some javadoc. Removed KataiStruct packet representations.

Add functional code that loads a pcap file and constructs the IP->hostname map/dictionary. Note that the map is actually of type Map<String, List<String>> as the trace contains cases where ONE IP maps to MULTIPLE hostnames. Bug in current implementation: the map should be changed to Map<String, Set<String>> to prevent the same hostname from showing up in the list multiple times (occurs when a set of DNS queries return the same IP).

Kaitai parser half baked; there seems to be a problem with the parsing of DNS packets (missing type A addresses in the data structure).

Managed to pick and parse DNS packets; but, still need to get the detailed information from inside the packet.

Reading and parsing through packets; handling unwanted packets; ready to create a good parser to create a nice data structure.

Skipping packets that do not have etherType, e.g. XID, EAPOL, etc.

Fixing build flow (broken because of a missing return statement).

Resolving merge conflict in Main.java

Adding the Kaitai library to parse PCAP files.

add notes

apply application plugin

add project for Smart Plug detection

Updating coloring for graphs.

Changing Packet Bytes into Traffic Volume in the generated time series graphs.

More scripts to plot graphs with labels.

SIGCOMM paper template

Adjustments for the addition of eth1 for SmartThings plug

Fixing G.nodes() iteration that needs us to force Python to create a copy for iteration condition by adding list()

Removing main_flow.sh; fixing flow to take time series plots from non DNS data

Working scripts and plots for 4 devices (smart plugs)

Adding combining plots script

Completing a new flow that will do automated analysis and graph generation for one device

Adding a new flow to yield per device data, analysis, and graphs.

Removing bipartite_iot_web_gexf_generator.py; the bipartite feature has been merged into base_gexf_generator.py

Merging bipartite functionality into the main base_gexf_generator.py script

Merge branch 'master' of https://github.uci.edu/rtrimana/smart_home_traffic

Adding the seconds in which there is 0 packet so that we will see the graph being plotted from 0

update base_gexf_generator with islocal node attribute
changes to networkx neighbors call - needs more updates
add flag for producing local-only graphs

Bipartite generator:
- Skip non IP traffic.
- Guard against cases where the device does not perform DNS lookups (or DNS lookups that occurred before data collection started).

Add bipartite graph generator. Needs to be merged with Rahmadi's changes to the base generator (I was unable to pull when implementing this functionaliy).

Adding binning capabilities to parse_packet_frequency.py script to smoothen and emphasize certain packet frequencies in the graph

Adding packet sizes and send/received bytes plots/analyses

Adding new analysis - incoming (not yet including outgoing) packets inter-arrival time

Adding traffic volume information into edges

Collapsing leaf nodes if they have the same set of protocols

Adding protocols as the property of edges; simplifying protocol tracking through scanning the frame.protocols field

Adding excluded devices list; Adding protocol names; restructuring, cleaning-up etc.

Establishing basic flow for the complete graph processing

Update base_gefx_generator.py to new pipeline

Separating incoming and outgoing traffic for a more fine-grained analysis

Adding moving window average using numpy library

Adding moving window average using numpy library

Completing flow for time series graph generation

Adding time series analysis run script

Setting device name as attribute (on Gephi we can choose to display/not display it)

Adding local device name mapping into graph

Adding list of MAC addresses for device translation

Restructuring files and folders

Restructuring files and folders

Restructuring files and folders

Update pipeline: graph now maps IoT devices' MACs to hostnames or other MACs (if local communication), and device-specific DNS queries are taken into account.
Changes:
- base_gefx_generator.py updated such that it considers MAC addresses instead of IPs and considers device-specific DNS queries for the IoT devices during graph construction.
- extract_from_tshark.py: updated to also include eth.src and eth.dst.
- parse_dns.py: corrected return value of hostname_for_ip_at_time such that the method simply returns the hostname instead of a tuple of timestamp and hostname.
- updated example json generated by extract_from_tshark.py
- added example gephi file generated by base_gefx_generator.py

Update parse_dns.py with new datastructure that captures all dns requests per device [NOTE: needs testing!]

Define DeviceDNSMap: class the stores a specific device's DNS mappings.

Initial experimentation with simple pipeline setup: Call parse_json_dns from parse_dns.py in base_gefx_generator.py
Add simple gitignore.
Add example wireshark DNS extract for testing.
Add example wireshark HTTP extract for testing.

Fixing indentation and results display

A simple script to analyze the distribution of packet frequencies against time

Update DNS parser to also construct IP-> hostname map [NOTE: This is the SIMPLEST SOLUTION and does not consider cases where one IP maps to multiple hostnames nor does it consider timing of the mappings -- serves only as a starting point]

Add parse_dns.py: reads DNS traffic from a file (JSON formatted by tshark) and constructs a map in which a hostname points to a set of IPs associated with that hostname.

extract_from_tshark.py:
- apply Shuba's fix: do not skip packets that do not have a comment.
- include src ip and src port in output

Add base_gefx_generator.py: script that constructs a .gefx file from JSON generated by extract_from_tshark.py. The script generates a graph in which nodes are hosts and edges indicate that there is communication between the hosts. The script label/identify hosts by their IPs. It should serve as a starting point when we want to include more information in the graphs (e.g. host name).

First version of scripts for traffic analysis

Initial commit