def comparator(self, asns=None):
js_name = config.get("web", "canvas_comparator_name")
if asns is None:
pass
else:
splitted_asns = asns.split()
g = GraphGenerator(js_name)
title = ""
for asn in splitted_asns:
if asn.isdigit():
self.report.prepare_graphe_js(asn)
# as_graph_infos : [ipv4, ipv6, dates, first_date, last_date]
as_graph_infos = self.report.graph_infos
g.add_line(
[as_graph_infos[0], as_graph_infos[2]], asn + " IPv4", as_graph_infos[3], as_graph_infos[4]
)
g.add_line(
[as_graph_infos[1], as_graph_infos[2]], asn + " IPv6", as_graph_infos[3], as_graph_infos[4]
)
title += asn + " "
if len(g.lines) > 0:
g.set_title(title)
g.make_js()
self.js = g.js
self.js_name = js_name
else:
self.js = self.js_name = None
def comparator(self, asns = None):
"""
Get the data needed to display the page of the comparator
FIXME: rewrite it!!
"""
js_name = self.config.get('web','canvas_comparator_name')
asns_to_return = []
if asns is not None:
splitted_asns = asns.split()
g = GraphGenerator(js_name)
title = ''
for asn in splitted_asns:
if asn.isdigit():
asns_to_return.append(asn)
graph_last_date = datetime.date.today()
graph_first_date = datetime.date.today() - datetime.timedelta(days=self.days_graph)
graph_dates = self.report.get_dates_from_interval(graph_first_date, graph_last_date)
dates_sources = self.report.get_all_sources(graph_dates)
all_ranks = self.report.get_all_ranks(asn, graph_dates, dates_sources)
data_graph, last_seen_sources = self.report.prepare_graphe_js(all_ranks, graph_dates, dates_sources)
g.add_line(data_graph, str(asn + self.report.ip_key), graph_dates)
title += asn + ' '
if len(g.lines) > 0:
g.set_title(title)
g.make_js()
self.js = g.js
self.js_name = js_name
else:
self.js = self.js_name = None
return " ".join(asns_to_return)
def make_graph(self, infos):
js_name = config.get('web','canvas_asn_name')
g = GraphGenerator(js_name)
g.add_line(infos, self.report.ip_key, self.graph_first_date, self.graph_last_date )
g.set_title(self.asn)
g.make_js()
self.js = g.js
self.js_name = js_name
def make_graph(self, infos):
js_name = config.get("web", "canvas_asn_name")
g = GraphGenerator(js_name)
g.add_line([infos[0], infos[2]], "IPv4", infos[3], infos[4])
g.add_line([infos[1], infos[2]], "IPv6", infos[3], infos[4])
g.set_title(self.asn)
g.make_js()
self.js = g.js
self.js_name = js_name
def make_graph(self, asn, infos):
"""
Generate the graph with the data provided by the model
"""
js_name = self.config.get('web','canvas_asn_name')
g = GraphGenerator(js_name)
graph_last_date = datetime.date.today()
graph_first_date = datetime.date.today() - datetime.timedelta(days=self.days_graph)
graph_dates = self.report.get_dates_from_interval(graph_first_date, graph_last_date)
g.add_line(infos, self.report.ip_key, graph_dates)
g.set_title(asn)
g.make_js()
self.js = g.js
self.js_name = js_name
def get_stats(self):
"""
Get data to diaplay on the RGraph graph
"""
stats = self.report.get_stats()
dates = self.get_dates()
lines = []
g = GraphGenerator('canvas_stats')
for date in dates:
line = self.report.prepare_distrib_graph(date)
sorted_label = sorted(line.keys())
g.add_line(line, date, sorted_label[3:-1])
g.set_title("stats")
g.make_js()
return stats, g.js, 'canvas_stats'
def get_test_result(filename, full_graph=False, chain_graph=False):
columns = [
'Count of nodes', 'BFS average time', 'BFS delta time', 'BFS memory',
'DFS average time', 'DFS delta time', 'DFS memory',
'Dijkstra average time', 'Dijkstra delta time', 'Dijkstra memory',
'Ford-Bellman average time', 'Ford-Bellman delta time',
'Ford-Bellman memory', 'A_Star average time', 'A_Star delta time',
'A_Star memory'
]
with open(filename, 'w', newline='') as file:
writer = csv.DictWriter(file,
dialect=csv.excel_tab(),
fieldnames=columns)
writer.writeheader()
tester = Tester()
for i in range(NUMBER_OF_TESTS):
if not chain_graph:
start_node = random.randint(0, NODE_COUNT + STEP * i - 1)
finish_node = random.randint(0, NODE_COUNT + STEP * i - 1)
else:
start_node = 0
finish_node = NODE_COUNT + STEP * i - 1
base_graph_generator = GraphGenerator(NODE_COUNT + STEP * i, False,
False, full_graph,
chain_graph)
graph = base_graph_generator.generate_graph()
weighted_ordered_graph_generator = GraphGenerator(
NODE_COUNT + STEP * i, True, True, full_graph, chain_graph)
weighted_graph = weighted_ordered_graph_generator.generate_graph()
negative_weighted_graph_generator = GraphGenerator(
NODE_COUNT + STEP * i,
True,
True,
full_graph,
chain_graph,
negative_weighted=True)
negative_weighted_graph = (
negative_weighted_graph_generator.generate_graph())
planar_graph_generator = GraphGenerator(NODE_COUNT + STEP * i,
True,
True,
chain_graph=chain_graph,
planar=True)
planar_graph = planar_graph_generator.generate_graph()
result_line = tester.get_test_line(NODE_COUNT + STEP * i,
start_node, finish_node, graph,
weighted_graph, planar_graph,
negative_weighted_graph)
writer.writerow(result_line)
def test_generate_unweighted_ordered_graph(self):
graph_generator = GraphGenerator(3, False, True)
graph = graph_generator.generate_graph()
self.assertIsInstance(graph, UnweightedOrderedGraph)
def test_generate_weighted_unordered_graph(self):
graph_generator = GraphGenerator(3, True, False)
graph = graph_generator.generate_graph()
self.assertIsInstance(graph, WeightedUnorderedGraph)
import networkx as nx
from matplotlib import pyplot as plt
from graph_node import Node
from vector import Vector
from math import atan2
from graph_generator import GraphGenerator
from graph import Graph
graph_generator = GraphGenerator()
graph1 = graph_generator.generate_circular(15, 15, 3 * 15 - 6, 3 * 15 - 6, 50)
nx_graph1 = graph1.get_nx_graph()
graph_generator.remove_random_edges(3, 7)
graph_generator.change_all_nodes_position(2)
graph2 = graph_generator.graph
nx_graph2 = graph2.get_nx_graph()
node1, node2, node3, node4 = Node(0, 10,
10), Node(1, 10,
20), Node(2, 20,
20), Node(3, 20, 10)
# graph = Graph([node1, node2, node3, node4], [(0, 1), (1, 2), (2, 3), (3, 0)])
# nx_graph1.add_node(node1.index, pos=(node1.x, node1.y))
# nx_graph1.add_node(node2.index, pos=(node2.x, node2.y))
# nx_graph1.add_node(node3.index, pos=(node3.x, node3.y))
# nx_graph1.add_node(node4.index, pos=(node4.x, node4.y))
# nx_graph1.add_edge(1, 2)
# nx_graph1.add_edge(2, 3)
# nx_graph1.add_edge(3, 4)
from graph_generator import GraphGenerator
import csv
import imdb
if __name__ == "__main__":
id_list = []
ia = imdb.IMDb()
with open('actors_id.csv', newline='') as csvfile:
for row in csv.reader(csvfile, delimiter=','):
id_list.append(row[0])
graph = GraphGenerator(id_list[:10], ia).generate()
graph.save()
def setUp(self):
self.g = GraphGenerator()
def test_is_tree(self):
graph = {'1': ['2', '3'], '2': ['3'], '3': ['1'], '4': []}
self.assertFalse(GraphGenerator.is_tree(graph))
graph = {'1': ['2', '3'], '2': ['1'], '3': ['4', '1'], '4': ['3']}
self.assertTrue(GraphGenerator.is_tree(graph))
class MainWindow(QMainWindow):
'''window for visualizing and controlling graphs'''
def __init__(self, parent=None) -> None:
super().__init__(parent)
self.setWindowTitle("Graph App")
self.renderer = GraphRender()
self.setCentralWidget(self.renderer)
# set up graph generator and renderer
self.graphGen = GraphGenerator()
self.graphGen.area_w = self.renderer.area_w
self.graphGen.area_h = self.renderer.area_h
self.graph = self.graphGen.genGraph()
self.renderer.setGraph(self.graph)
self.newGraph()
# set up menus and bars
file_menu = self.menuBar().addMenu("&File")
file_menu.addAction("&New")
file_menu.addAction("&Save")
file_menu.addAction("&Load")
file_menu.addAction("E&xit", self.close)
view_menu = self.menuBar().addMenu("&View")
view_menu.addAction("Voronoi &Background",
self.renderer.drawBackground)
toolBar = self.createToolBar()
toolBar.setOrientation(Qt.Vertical)
self.addToolBar(Qt.RightToolBarArea, toolBar)
statusBar = QStatusBar()
statusBar.showMessage("Status Bar! More down to earth than Space Bar.")
self.setStatusBar(statusBar)
def createToolBar(self) -> QToolBar:
toolBar = QToolBar(self)
toolBar.addAction("New Graph", self.newGraph)
toolBar.addSeparator()
toolBar.addWidget(QLabel("Node generator:"))
nodeStratBox = QComboBox(toolBar)
nodeStratBox.addItems(self.graphGen.nodeStrategyList)
nodeStratBox.currentIndexChanged.connect(self.setNewNodeStrategy)
nodeStratBox.setCurrentIndex(self.graphGen.nodeStrategy)
toolBar.addWidget(nodeStratBox)
toolBar.addWidget(QLabel("\nEdge generator:"))
edgeStratBox = QComboBox(toolBar)
edgeStratBox.addItems(self.graphGen.edgeStrategyList)
edgeStratBox.currentIndexChanged.connect(self.setNewEdgeStrategy)
edgeStratBox.setCurrentIndex(self.graphGen.edgeStrategy)
toolBar.addWidget(edgeStratBox)
toolBar.addSeparator()
toolBar.addWidget(QLabel("Generator settings", toolBar))
self.regionNumberX = QSpinBox()
self.regionNumberX.setRange(1, 100)
self.regionNumberX.setValue(self.graphGen.numberOfRegionsX)
self.regionNumberX.valueChanged.connect(self.setNumberOfRegionsX)
self.regionNumberY = QSpinBox()
self.regionNumberY.setRange(1, 100)
self.regionNumberY.setValue(self.graphGen.numberOfRegionsY)
self.regionNumberY.valueChanged.connect(self.setNumberOfRegionsY)
self.nodeNumber = QSpinBox()
self.nodeNumber.setRange(1, 100)
self.nodeNumber.setValue(self.graphGen.numberOfNodes)
self.nodeNumber.valueChanged.connect(self.setNumberOfNodes)
self.edgeChance = QSpinBox()
self.edgeChance.setRange(0, 100)
self.edgeChance.setValue(self.graphGen.connection_chance)
self.edgeChance.valueChanged.connect(self.setConnectionChance)
graphGrid = QGridLayout()
graphGrid.setColumnMinimumWidth(0, 20)
graphGrid.setColumnMinimumWidth(1, 30)
graphGrid.addWidget(QLabel("Regions X:"))
graphGrid.addWidget(self.regionNumberX)
graphGrid.addWidget(QLabel("Regions Y:"))
graphGrid.addWidget(self.regionNumberY)
graphGrid.addWidget(QLabel("Node number:"))
graphGrid.addWidget(self.nodeNumber)
graphGrid.addWidget(QLabel("Edge forming\nchance:"))
graphGrid.addWidget(self.edgeChance)
graphGridHolder = QWidget()
graphGridHolder.setLayout(graphGrid)
toolBar.addWidget(graphGridHolder)
toolBar.addSeparator()
toolBar.addAction("Exit", self.close)
return toolBar
def newGraph(self):
self.graph = self.graphGen.genGraph()
#self.graph.highlighted_node = graph_methods.breadth_first(self.graph, self.graph.nodes[0])
#graph_methods.highlightComponents(self.graph)
graph_methods.highlightSpanningTree(self.graph)
self.renderer.repaint()
def setNewNodeStrategy(self, index: int):
self.graphGen.nodeStrategy = index
def setNewEdgeStrategy(self, index: int):
self.graphGen.edgeStrategy = index
def setNumberOfNodes(self, value: int):
self.graphGen.numberOfNodes = value
if value <= 10:
self.renderer.pixel_size = 32
elif value <= 20:
self.renderer.pixel_size = 16
elif value <= 40:
self.renderer.pixel_size = 8
elif value <= 80:
self.renderer.pixel_size = 4
else:
self.renderer.pixel_size = 2
def setConnectionChance(self, value: int):
self.graphGen.connection_chance = value
def setNumberOfRegionsX(self, value: int):
self.graphGen.numberOfRegionsX = value
def setNumberOfRegionsY(self, value: int):
self.graphGen.numberOfRegionsY = value
def test_family_graph1(self):
attrs = {
'get_person_main.side_effect': self.get_person_main,
'get_movie.side_effect': self.get_movie
}
ia = MagicMock(**attrs)
graph = GraphGenerator(self.actor_ids, ia, max_threads=4).generate()
self.assertEqual(None, graph.get_edge("Maxim", "Lilia"))
self.assertEqual({"Sumy"}, graph.get_edge("Maxim", "Kostya"))
self.assertEqual({"Sumy"}, graph.get_edge("Kostya", "Maxim"))
self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Svetlana"))
self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Elena"))
self.assertEqual({"Moscow"}, graph.get_edge("Kostya", "Lilia"))
self.assertEqual({"Moscow"}, graph.get_edge("Lilia", "Svetlana"))
self.assertEqual({"Moscow", "Budapest"},
graph.get_edge("Lilia", "Elena"))
self.assertEqual({"Moscow"}, graph.get_edge("Lilia", "Kostya"))
self.assertEqual({"Moscow"}, graph.get_edge("Svetlana", "Lilia"))
self.assertEqual({"Moscow", "New York"},
graph.get_edge("Svetlana", "Elena"))
self.assertEqual({"Moscow"}, graph.get_edge("Svetlana", "Kostya"))
self.assertEqual({"New York"}, graph.get_edge("Svetlana", "Irina"))
self.assertEqual({"Moscow", "Budapest"},
graph.get_edge("Elena", "Lilia"))
self.assertEqual({"Moscow", "New York"},
graph.get_edge("Elena", "Svetlana"))
self.assertEqual({"Moscow"}, graph.get_edge("Elena", "Kostya"))
self.assertEqual({"New York"}, graph.get_edge("Elena", "Irina"))
self.assertEqual({"New York"}, graph.get_edge("Irina", "Elena"))
self.assertEqual({"New York"}, graph.get_edge("Irina", "Svetlana"))
number_of_pattern_vertices, number_of_pattern_edges,
number_of_pattern_vertex_labels,
number_of_pattern_edge_labels)
graph_generators = list()
for p in range(CONFIG["number_of_patterns"]):
pattern = ig.read(
os.path.join(save_pattern_dir,
patterns_id + "_%d.gml" % (p)))
pattern.vs["label"] = [
int(x) for x in pattern.vs["label"]
]
pattern.es["label"] = [
int(x) for x in pattern.es["label"]
]
pattern.es["key"] = [int(x) for x in pattern.es["key"]]
graph_generators.append(GraphGenerator(pattern))
for alpha in CONFIG["alphas"]:
for number_of_graph_vertices in CONFIG[
"number_of_graph_vertices"]:
if number_of_graph_vertices < number_of_pattern_vertices:
continue
for number_of_graph_vertex_labels in CONFIG[
"number_of_graph_vertex_labels"]:
if number_of_graph_vertex_labels > number_of_graph_vertices:
continue
if number_of_graph_vertex_labels < number_of_pattern_vertex_labels:
continue
for number_of_graph_edges in CONFIG[
"number_of_graph_edges"]:
if number_of_graph_edges < number_of_graph_vertices - 1: # not connected
continue
from event_finder import EventFinder
from graph_generator import GraphGenerator
from graph_traverser import GraphTraverser
from input_parser import Parser
from possibilities import Possibilities
from state_node import StateNode
parser = Parser()
startNodeSet = parser.parseStartNodes()
adjList = parser.parseReachability()
vulnDict, portDict = parser.parseVulnerabilities()
eventMapping = parser.parseEventMapping()
eventSet = EventFinder()
# Generate attack graph
graphGenerator = GraphGenerator(startNodeSet, adjList, vulnDict, portDict)
DG = graphGenerator.generate_graph()
timestamp, src, dst, port, description, accessLevel = parser.parseNotableEvent(
)
graphTraverser = GraphTraverser(DG, eventSet, eventMapping, portDict.keys())
eventSequence = graphTraverser.start_traversal(timestamp, src, dst, port,
description, accessLevel)
# Print possibilities
crownJewelSet = parser.parseCrownJewels()
possibilitiesGenerator = Possibilities()
notableEventStateNode = StateNode(dst, accessLevel)
possibilitiesGenerator.printPossiblePaths(DG, notableEventStateNode,
crownJewelSet)
