[Mininet]SDN实验

export DISPLAY=:0
sudo python2.7 mininet/examples/miniedit.py

from mininet.net import Mininet
from mininet.topo import LinearTopo
from mininet.cli import CLI

def create_linear_topology():
    topo = LinearTopo(k=4)  # 创建线性拓扑，k=4表示有4个主机
    net = Mininet(topo)  # 创建Mininet网络
    net.start()  # 启动网络
    CLI(net)  # 打开Mininet命令行界面
    net.stop()  # 停止网络

if __name__ == "__main__":
    create_linear_topology()

from mininet.net import Mininet
from mininet.topo import SingleSwitchTopo
from mininet.cli import CLI

def create_single_topology():
    topo = SingleSwitchTopo(k=3)  # 创建单一拓扑，k=3表示有3个主机
    net = Mininet(topo)  # 创建Mininet网络
    net.start()  # 启动网络
    CLI(net)  # 打开Mininet命令行界面
    net.stop()  # 停止网络

if __name__ == "__main__":
    create_single_topology()

from mininet.net import Mininet
from mininet.topolib import TreeTopo
from mininet.cli import CLI

def create_tree_topology():
    topo = TreeTopo(depth=2, fanout=2)  # 创建树状拓扑，深度为2，扇出为2
    net = Mininet(topo)  # 创建Mininet网络
    net.start()  # 启动网络
    CLI(net)  # 打开Mininet命令行界面
    net.stop()  # 停止网络

if __name__ == "__main__":
    create_tree_topology()

from mininet.net import Mininet
from mininet.node import CPULimitedHost
from mininet.node import TCIntf
from mininet.link import TCLink
from mininet.cli import CLI

def create_network_topology():
    net = Mininet()

    # 添加主机，并设置CPU限制为20%
    h1 = net.addHost('h1', cls=CPULimitedHost, cpu=0.2)
    h2 = net.addHost('h2', cls=CPULimitedHost, cpu=0.2)

    # 添加交换机
    s1 = net.addSwitch('s1', cls=OVSSwitch, failMode='standalone')

    # 添加链路，并设置带宽、延迟、最大队列大小和损耗率
    net.addLink(h1, s1, bw=10, delay='10ms', max_queue_size=100, loss=10)
    net.addLink(h2, s1, bw=10, delay='10ms', max_queue_size=100, loss=10)

    net.start()
    CLI(net)
    net.stop()

if __name__ == "__main__":
    create_network_topology()

from mininet.net import Mininet
from mininet.link import TCLink
from mininet.cli import CLI
from mininet.node import *

def create_network_topology():
  net = Mininet()

  # 添加交换机
  s1 = net.addSwitch('s1', cls=OVSSwitch, failMode='standalone') 

  # 添加主机，并设置CPU限制为20%
  h1 = net.addHost('h1', cls=CPULimitedHost, cpu=0.2, cores=1) 
  h2 = net.addHost('h2', cls=CPULimitedHost, cpu=0.2, cores=1)

  # 添加链路，并设置带宽、延迟、最大队列大小和损耗率
  net.addLink(h1, s1, cls=TCLink, bw=10, delay='10ms', max_queue_size=100, loss=20)
  net.addLink(h2, s1, cls=TCLink, bw=10, delay='10ms', max_queue_size=100, loss=20)

  net.start()

  # 设置网卡参数
  intf1 = s1.intf('s1-eth1')
  intf1.setIP('10.0.0.11/24')
  intf2 = s1.intf('s1-eth2')
  intf2.setIP('10.0.0.22/24')
  
  intf_h1 = h1.intf('h1-eth0')
  intf_h1.setIP('10.0.0.1/24') 
  intf_h2 = h2.intf('h2-eth0')
  intf_h2.setIP('10.0.0.2/24') 

  CLI(net)
  net.stop()

if __name__ == "__main__":
  create_network_topology()

import requests
import json

controller_ip = '127.0.0.1'
switch_dpid = '00:00:00:00:00:00:00:01'
h1_mac_address = '00:00:00:00:00:01'
blocking_port = '1'

url = f'http://{controller_ip}:8080/wm/staticflowpusher/json'

headers = {
    'Content-Type': 'application/json'
}

data = {
    'switch': switch_dpid,
    'name': 'block-h1',
    'priority': '100',
    'in_port': blocking_port,
    'eth-src': h1_mac_address,
    'active': 'true',
    'actions': 'drop'  # 阻断动作：丢弃数据包
}

response = requests.post(url, headers=headers, data=json.dumps(data))

if response.status_code == 200:
    print('流表项成功添加，h1 发出的数据包将被阻断.')
else:
    print('无法添加流表项.')
    print(response.text)  

from pox.core import core
import pox.openflow.libopenflow_01 as of

log = core.getLogger()

class SimpleFirewall(object):
    def __init__(self):
        self.blocked_mac = '00:00:00:00:00:01'
        core.openflow.addListeners(self)

    def _handle_ConnectionUp(self, event):
        log.info("Switch %s connected", event.connection)

    def _handle_PacketIn(self, event):
        packet = event.parsed

        # 检查源MAC地址是否在要阻止的列表中
        if packet.src == self.blocked_mac:
            log.warning("Blocked packet from MAC %s", packet.src)
            # 使用 OFPP_NONE 阻止数据包
            msg = of.ofp_packet_out()
            msg.data = event.ofp
            msg.actions.append(of.ofp_action_output(port=of.OFPP_NONE))
            event.connection.send(msg)
        else:
            # 源MAC地址不在列表中，则转发数据包到所有其他端口
            msg = of.ofp_packet_out()
            msg.data = event.ofp
            msg.actions.append(of.ofp_action_output(port=of.OFPP_ALL))
            event.connection.send(msg)

def launch():
    core.registerNew(SimpleFirewall)
    log.info("SimpleFirewall is running.")

from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet

class SimpleHub(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SimpleHub, self).__init__(*args, **kwargs)

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # 安装流表项，将所有数据包输出到所有端口
        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
        self.add_flow(datapath, 0, match, actions)

    def add_flow(self, datapath, priority, match, actions, buffer_id=None):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
                                    priority=priority, match=match,
                                    instructions=inst)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                    match=match, instructions=inst)
        datapath.send_msg(mod)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # 解析数据包
        pkt = packet.Packet(msg.data)
        eth_pkt = pkt.get_protocol(ethernet.ethernet)

        # 处理以太网帧
        if eth_pkt.ethertype == ether_types.ETH_TYPE_IP:
            pass

        # 发送到控制器以便进一步处理
        self.send_packet_out(datapath, msg)

    def send_packet_out(self, datapath, msg):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
        out = parser.OFPPacketOut(
            datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.in_port,
            actions=actions, data=msg.data
        )
        datapath.send_msg(out)

if __name__ == "__main__":
    app_manager.main()

from ryu.lib.mac import haddr_to_bin
from ryu.base import app_manager
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, ether_types
from ryu.controller import ofp_event

class SimpleSwitch(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SimpleSwitch, self).__init__(*args, **kwargs)
        self.mac_to_port = {}

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        # 安装默认流表项，将未知目的MAC地址的数据包输出到控制器
        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]
        self.add_flow(datapath, 0, match, actions)

    def add_flow(self, datapath, priority, match, actions, buffer_id=None):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
                                    priority=priority, match=match,
                                    instructions=inst)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                    match=match, instructions=inst)
        datapath.send_msg(mod)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        pkt = packet.Packet(msg.data)
        eth_pkt = pkt.get_protocol(ethernet.ethernet)

        # 只处理以太网帧
        if eth_pkt.ethertype == ether_types.ETH_TYPE_IP:
            pass

        dst = eth_pkt.dst
        src = eth_pkt.src
        in_port = msg.match['in_port']

        # 学习源MAC地址和输入端口的映射关系
        self.mac_to_port.setdefault(datapath.id, {})
        self.mac_to_port[datapath.id][src] = in_port

        # 查找目的MAC地址对应的端口号
        if dst in self.mac_to_port[datapath.id]:
            out_port = self.mac_to_port[datapath.id][dst]
        else:
            out_port = ofproto.OFPP_FLOOD

        # 安装流表项，将数据包发送到目的端口
        actions = [parser.OFPActionOutput(out_port)]
        match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
        self.add_flow(datapath, 1, match, actions, msg.buffer_id)

        # 发送数据包到目的端口
        self.send_packet_out(datapath, msg, out_port)

    def send_packet_out(self, datapath, msg, out_port):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        actions = [parser.OFPActionOutput(out_port)]
        out = parser.OFPPacketOut(
            datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.match['in_port'],
            actions=actions, data=msg.data
        )
        datapath.send_msg(out)