Restructuring files and folders
[pingpong.git] / origin / base_gefx_generator.py
1 #!/usr/bin/python
2
3 """
4 Script that constructs a graph in which hosts are nodes.
5 An edge between two hosts indicate that the hosts communicate.
6 Hosts are labeled and identified by their IPs.
7 The graph is written to a file in Graph Exchange XML format for later import and visual inspection in Gephi.
8
9 The input to this script is the JSON output by extract_from_tshark.py by Anastasia Shuba.
10
11 This script is a simplification of Milad Asgari's parser_data_to_gephi.py script.
12 It serves as a baseline for future scripts that want to include more information in the graph.
13 """
14
15 import socket
16 import json
17 import tldextract
18 import networkx as nx
19 import sys
20 from decimal import *
21
22 import parse_dns
23
24 JSON_KEY_ETH_SRC = "eth.src"
25 JSON_KEY_ETH_DST = "eth.dst"
26
27 def parse_json(file_path):
28
29     device_dns_mappings = parse_dns.parse_json_dns("./dns.json")
30
31     # Init empty graph
32     G = nx.DiGraph() 
33     with open(file_path) as jf:
34         # Read JSON.
35         # data becomes reference to root JSON object (or in our case json array)
36         data = json.load(jf)
37         # Loop through json objects in data
38         for k in data:
39             # Fetch timestamp of packet
40             packet_timestamp = Decimal(data[k]["ts"])
41             # Fetch eth source and destination info
42             eth_src = data[k][JSON_KEY_ETH_SRC]
43             eth_dst = data[k][JSON_KEY_ETH_DST]
44             # Traffic can be both outbound and inbound.
45             # Determine which one of the two by looking up device MAC in DNS map.
46             iot_device = None
47             if eth_src in device_dns_mappings:
48                 iot_device = eth_src
49             elif eth_dst in device_dns_mappings:
50                 iot_device = eth_dst
51             else:
52                 print "[ WARNING: DNS mapping not found for device with MAC", eth_src, "OR", eth_dst, "]"
53                 # This must be local communication between two IoT devices OR an IoT device talking to a hardcoded IP.
54                 # For now let's assume local communication.
55                 # Add a node for each device and an edge between them.
56                 G.add_node(eth_src)
57                 G.add_node(eth_dst)
58                 G.add_edge(eth_src, eth_dst)
59                 # TODO add regex check on src+dst IP to figure out if hardcoded server IP (e.g. check if one of the two are NOT a 192.168.x.y IP)
60                 continue
61             # It is outbound traffic if iot_device matches src, otherwise it must be inbound traffic.
62             outbound_traffic = iot_device == eth_src
63
64             ''' Graph construction '''
65             # No need to check if the Nodes and/or Edges we add already exist:
66             # NetworkX won't add already existing nodes/edges (except in the case of a MultiGraph or MultiDiGraph (see NetworkX doc)).
67             
68             # Add a node for each host.
69             # First add node for IoT device.
70             G.add_node(iot_device)
71             # Then add node for the server.
72             # For this we need to distinguish between outbound and inbound traffic so that we look up the proper IP in our DNS map.
73             # For outbound traffic, the server's IP is the destination IP.
74             # For inbound traffic, the server's IP is the source IP.
75             server_ip = data[k]["dst_ip"] if outbound_traffic else data[k]["src_ip"]
76             hostname = device_dns_mappings[iot_device].hostname_for_ip_at_time(server_ip, packet_timestamp)
77             if hostname is None:
78                 # TODO this can occur when two local devices communicate OR if IoT device has hardcoded server IP.
79                 # However, we only get here for the DNS that have not performed any DNS lookups
80                 # We should use a regex check early in the loop to see if it is two local devices communicating.
81                 # This way we would not have to consider these corner cases later on.
82                 print "[ WARNING: no ip-hostname mapping found for ip", server_ip, " -- adding eth.src->eth.dst edge, but note that this may be incorrect if IoT device has hardcoded server IP ]"
83                 G.add_node(eth_src)
84                 G.add_node(eth_dst)
85                 G.add_edge(eth_src, eth_dst)
86                 continue
87             G.add_node(hostname)
88             # Connect the two nodes we just added.
89             if outbound_traffic:
90                 G.add_edge(iot_device, hostname)
91             else:
92                 G.add_edge(hostname, iot_device)
93     return G
94
95 # ------------------------------------------------------
96 # Not currently used.
97 # Might be useful later on if we wish to resolve IPs.
98 def get_domain(host):
99     ext_result = tldextract.extract(str(host))
100     # Be consistent with ReCon and keep suffix
101     domain = ext_result.domain + "." + ext_result.suffix
102     return domain
103
104 def is_IP(addr):
105     try:
106         socket.inet_aton(addr)
107         return True
108     except socket.error:
109         return False
110 # ------------------------------------------------------
111
112 if __name__ == '__main__':
113     if len(sys.argv) < 3:
114         print "Usage:", sys.argv[0], "input_file output_file"
115         print "outfile_file should end in .gexf"
116         sys.exit(0)
117     # Input file: Path to JSON file generated from tshark JSON output using Anastasia's script (extract_from_tshark.py).
118     input_file = sys.argv[1]
119     print "[ input_file  =", input_file, "]"
120     # Output file: Path to file where the Gephi XML should be written.
121     output_file = sys.argv[2]
122     print "[ output_file =", output_file, "]"
123     # Construct graph from JSON
124     G = parse_json(input_file)
125     # Write Graph in Graph Exchange XML format
126     nx.write_gexf(G, output_file)