Example #1
0
    def get_g():
        """
        Get a simple graph of 4 mesh connected graph
        :return: NetworkGraph
        """
        # Start with some initial inputs
        # This input only define routers, interfaces, and networks
        g_phy = NetworkGraph()
        g_phy.add_router('R1')
        g_phy.add_router('R2')
        g_phy.add_router('R3')
        g_phy.add_router('R4')
        g_phy.enable_ospf('R1', 100)
        g_phy.enable_ospf('R2', 100)
        g_phy.enable_ospf('R3', 100)
        g_phy.enable_ospf('R4', 100)

        g_phy.add_router_edge('R1', 'R2')
        g_phy.add_router_edge('R1', 'R3')
        g_phy.add_router_edge('R1', 'R4')
        g_phy.add_router_edge('R2', 'R1')
        g_phy.add_router_edge('R2', 'R3')
        g_phy.add_router_edge('R2', 'R4')
        g_phy.add_router_edge('R3', 'R1')
        g_phy.add_router_edge('R3', 'R2')
        g_phy.add_router_edge('R3', 'R4')
        g_phy.add_router_edge('R4', 'R1')
        g_phy.add_router_edge('R4', 'R2')
        g_phy.add_router_edge('R4', 'R3')
        conn_syn = ConnectedSyn([], g_phy, full=True)
        conn_syn.synthesize()
        return g_phy
Example #2
0
def ospf_net():
    graph = NetworkGraph()
    r1, r2, r3, r4 = 'R1', 'R2', 'R3', 'R4'
    # Add routers
    graph.add_router(r1)
    graph.add_router(r2)
    graph.add_router(r3)
    graph.add_router(r4)
    # Connect routers
    graph.add_router_edge(r1, r2)
    graph.add_router_edge(r2, r1)
    graph.add_router_edge(r1, r3)
    graph.add_router_edge(r3, r1)
    graph.add_router_edge(r4, r2)
    graph.add_router_edge(r2, r4)
    graph.add_router_edge(r4, r3)
    graph.add_router_edge(r3, r4)
    # Enable OSPF
    graph.enable_ospf(r1, 100)
    graph.enable_ospf(r2, 100)
    graph.enable_ospf(r3, 100)
    graph.enable_ospf(r4, 100)
    # Assign interfaces
    graph.set_iface_names()
    # Add networks
    for router in graph.routers_iter():
        for iface in graph.get_ifaces(router):
            graph.add_ospf_network(router, iface, 0)
    # Set the edge costs
    graph.set_edge_ospf_cost(r1, r2, 100)
    graph.set_edge_ospf_cost(r1, r3, 200)
    graph.set_edge_ospf_cost(r2, r4, 50)
    graph.set_edge_ospf_cost(r3, r4, 300)
    # Edge costs for the reverse direction
    graph.set_edge_ospf_cost(r4, r2, 100)
    graph.set_edge_ospf_cost(r4, r3, 100)
    graph.set_edge_ospf_cost(r2, r1, 100)
    graph.set_edge_ospf_cost(r3, r1, 100)
    # Synthesize connectivity
    syn = ConnectedSyn(graph, full=True)
    assert syn.synthesize()
    # Write the configs
    gns3 = GNS3Topo(graph)
    tmpdir = tempfile.mkdtemp(suffix='-ospf')
    gns3.write_configs(tmpdir)
    print("Wrote configurations to %s" % tmpdir)
Example #3
0
def two_ibgp_nodes(export_path):
    """
    Two routers connected via iBGP
    Very simple once router announces a single prefix and the other selects it
    """
    graph = NetworkGraph()
    r1, r2 = 'R1', 'R2'
    graph.add_router(r1)
    graph.add_router(r2)
    graph.add_router_edge(r1, r2)
    graph.add_router_edge(r2, r1)

    # BGP configs
    graph.set_bgp_asnum(r1, 100)
    graph.set_bgp_asnum(r2, 100)
    # Establish peering
    # The actual network interfaces used for peering will be synthesized
    graph.add_bgp_neighbor(r1,
                           r2,
                           router_a_iface=VALUENOTSET,
                           router_b_iface=VALUENOTSET)

    # Enable OSPF
    graph.enable_ospf(r1, 100)
    graph.enable_ospf(r2, 100)
    graph.add_ospf_network(r1, 'lo100', 0)
    graph.add_ospf_network(r2, 'lo100', 0)
    for iface in graph.get_ifaces(r1):
        graph.add_ospf_network(r1, iface, 0)
    for iface in graph.get_ifaces(r2):
        graph.add_ospf_network(r2, iface, 0)

    # Some internal network
    net = ip_network(u'128.0.0.0/24')
    prefix = '128_0_0_0'
    prefix_map = {prefix: net}
    lo0 = 'lo10'
    graph.set_loopback_addr(
        r1, lo0, ip_interface("%s/%d" % (net.hosts().next(), net.prefixlen)))
    # Announce the internal network
    graph.add_bgp_announces(r1, lo0)

    # The communities recognized by us
    comms = [Community("100:10"), Community("100:20")]

    # The announcement that will be propagated by R1
    ann = Announcement(prefix=prefix,
                       peer=r1,
                       origin=BGP_ATTRS_ORIGIN.EBGP,
                       next_hop='R1Hop',
                       as_path=[100],
                       as_path_len=1,
                       local_pref=100,
                       med=100,
                       communities=dict([(c, False) for c in comms]),
                       permitted=True)

    path = PathReq(Protocols.BGP, prefix, ['R2', 'R1'], False)
    reqs = [path]

    # Get SMT Context
    ctx = create_context(reqs, graph, [ann])
    propagation = EBGPPropagation(reqs, graph, ctx)
    propagation.compute_dags()
    propagation.synthesize()

    # SMT Solving
    solver = z3.Solver(ctx=ctx.z3_ctx)
    assert ctx.check(solver) == z3.sat, solver.unsat_core()

    # Update graph with the concrete values after solver
    ConnectedSyn([], graph, full=True).synthesize()
    propagation.update_network_graph()

    gns3 = GNS3Topo(graph=graph, prefix_map=prefix_map)
    gns3.write_configs('%s/ibgp-simple' % export_path)
Example #4
0
def ibgp_net():
    graph = NetworkGraph()
    peer, r1, r2, r3, r4 = 'Ext', 'R1', 'R2', 'R3', 'R4'
    # Add routers
    graph.add_peer(peer)
    graph.add_router(r1)
    graph.add_router(r2)
    graph.add_router(r3)
    graph.add_router(r4)
    # Connect routers
    graph.add_peer_edge(peer, r1)
    graph.add_peer_edge(r1, peer)
    graph.add_router_edge(r1, r2)
    graph.add_router_edge(r2, r1)
    graph.add_router_edge(r1, r3)
    graph.add_router_edge(r3, r1)
    graph.add_router_edge(r4, r2)
    graph.add_router_edge(r2, r4)
    graph.add_router_edge(r4, r3)
    graph.add_router_edge(r3, r4)
    # Enable OSPF
    graph.enable_ospf(r1, 100)
    graph.enable_ospf(r2, 100)
    graph.enable_ospf(r3, 100)
    graph.enable_ospf(r4, 100)
    # Set BGP ASN
    graph.set_bgp_asnum(peer, 200)
    graph.set_bgp_asnum(r1, 100)
    graph.set_bgp_asnum(r2, 100)
    graph.set_bgp_asnum(r3, 100)
    graph.set_bgp_asnum(r4, 100)
    # Establish BGP peering
    graph.add_bgp_neighbor(peer, r1)
    graph.add_bgp_neighbor(r1, r2)
    graph.add_bgp_neighbor(r1, r3)
    graph.add_bgp_neighbor(r1, r4)
    graph.add_bgp_neighbor(r2, r3)
    graph.add_bgp_neighbor(r2, r4)
    graph.add_bgp_neighbor(r3, r4)
    # Assign interfaces
    graph.set_iface_names()
    # Some internal to be announced network
    net = ip_network(u'128.0.0.0/24')
    prefix = '128_0_0_0'
    lo0 = 'lo0'
    prefix_map = {prefix: net}
    loaddr = ip_interface("%s/%d" % (net.hosts().next(), net.prefixlen))
    graph.set_loopback_addr(peer, lo0, loaddr)
    graph.add_bgp_announces(peer, lo0)

    # Synthesize connectivity
    syn = ConnectedSyn(graph, full=True, default_ibgp_lo='lo10')
    assert syn.synthesize()

    # Some route map
    actions = [ActionSetLocalPref(200)]
    line = RouteMapLine(matches=None,
                        actions=actions,
                        access=Access.permit,
                        lineno=100)
    route_map = RouteMap(name="ImpPolicy", lines=[line])
    graph.add_route_map(r1, route_map)
    graph.add_bgp_import_route_map(r1, peer, route_map.name)
    # Add networks
    # Note, some of the loop back interfaces where generated due to
    # ibgp peering in ConnectedSyn
    for router in graph.local_routers_iter():
        for iface in graph.get_ifaces(router):
            graph.add_ospf_network(router, iface, 0)
        for lo in graph.get_loopback_interfaces(router):
            graph.add_ospf_network(router, lo, 0)

    # Write the configs
    gns3 = GNS3Topo(graph, prefix_map=prefix_map)
    gns3.write_configs('out-configs/ibgp')