Beispiel #1
0
    def __init__(self, pkt, port_id, state_vars_dict,
                 symbolic_state_vars_dict):
        self.mapping = dict()
        if pkt is not None:
            self.mapping[Input('ethSrc')] = Mac(pkt.ethSrc)
            self.mapping[Input('ethDst')] = Mac(pkt.ethDst)
            self.mapping[Input('ethType')] = EthType(pkt.ethType)
            self.mapping[Input('port_id')] = Port(port_id)
            if pkt.vlan is not None:
                self.mapping[Input('vlan')] = Vlan(pkt.vlan)
                self.mapping[Input('vlanPcp')] = PriorityCode(pkt.vlanPcp)

            if pkt.ip4Src is not None:
                self.mapping[Input('ip4Src')] = IPAddr(pkt.ip4Src)
                self.mapping[Input('ip4Dst')] = IPAddr(pkt.ip4Dst)
                self.mapping[Input('ipProto')] = IPProto(pkt.ipProto)

            if pkt.tcpSrcPort is not None:
                self.mapping[Input('tcpSrcPort')] = TCPPort(pkt.tcpSrcPort)
                self.mapping[Input('tcpSrcPort')] = TCPPort(pkt.tcpDstPort)

        self.state_vars_dict = state_vars_dict
        for _, sv in state_vars_dict.items():
            self.mapping[Input(sv.name)] = sv.vartype(sv.value)
        self.symbolic_state_vars_dict = symbolic_state_vars_dict
Beispiel #2
0
from macros.expression import Implies, Match, ActionList, EQ, GT, NEQ, Action
from macros.types import IPAddr, Port
from macros.variables import Input, Output, FreeVariable
from macros.macro import Invariant, Precedence, Reaction

invariants = list()
precedences = list()
reactions = list()

react1 = Reaction(
    Match([EQ(Input("ip4Src"), IPAddr("10.0.0.3"))]),
    Implies(Match([
        EQ(Input("ip4Src"), IPAddr("10.0.0.1")),
    ]), ActionList([Action([EQ(Output("port_id_out"), Port(2))])])),
    Match([EQ(Input("ip4Src"), IPAddr("10.0.0.4"))]))

react2 = Reaction(
    Match([EQ(Input("ip4Src"), IPAddr("10.0.0.3"))]),
    Implies(Match([
        EQ(Input("ip4Src"), IPAddr("10.0.0.2")),
    ]), ActionList([Action([EQ(Output("port_id_out"), Port(1))])])),
    Match([EQ(Input("ip4Src"), IPAddr("10.0.0.4"))]))

reactions.append(react1)
reactions.append(react2)

#reactions.append(react)
Beispiel #3
0
                        )
                    ]
                )
            ]
        )
    )
)
"""
inv2 = Invariant(
    Implies(
        Match([
            EQ(Input("ip4Src"), IPAddr("127.0.0.1")),
        ]),
        ActionList([Action([EQ(IPAddr("127.0.0.1"), IPAddr("127.0.0.1"))])])))

inv3 = Invariant(ActionList([Action([GT(Output("port_id_out"), Port(127))])]))
invariants.append(inv)
invariants.append(inv2)
invariants.append(inv3)

react = Reaction(
    Match([
        EQ(Input("ethSrc"), FreeVariable("X", "Mac")),
        EQ(Input("port_id"), FreeVariable("P", "Port"))
    ]),
    Implies(
        Match([EQ(Input("ethDst"), FreeVariable("X", "Mac"))]),
        ActionList([
            Action([
                EQ(Output("port_id_out"), FreeVariable("P", "Port")),
                GT(FreeVariable("P", "Port"), Port(3))
Beispiel #4
0
invariants = list()
precedences = list()
reactions = list()

symbolic_state_var_list = list()

sv = StateVar("block", Bool, False)
state_var_list.append(sv)
ssv = SymbolicStateVar("learnt", IPAddr, Bool, False)
symbolic_state_var_list.append(ssv)
tt = Invariant(
    Implies(
        Match([
            EQ(Input("ip4Dst"), FreeVariable("X", "IPAddr")),
            EQ(Input("learnt", FreeVariable("X", "IPAddr")), Bool(False))
        ]), ActionList([Action([EQ(Output("port_id_out"), Port(100))])])))

tt2 = Invariant(
    Implies(
        Match([
            EQ(Input("ip4Src"), FreeVariable("X", "IPAddr")),
        ]),
        ActionList([
            Action([
                EQ(Output("learnt_out", FreeVariable("X", "IPAddr")),
                   Bool(True))
            ])
        ])))

react1 = Reaction(
    Match([
Beispiel #5
0
            [
                EQ(
                    Input("ip4Src"),
                    IPAddr("10.0.0.1")
                ),
            ]

        ),
        ActionList(
            [
                Action(
                    [
                        EQ(
                            Output("port_id_out"),
                            Port(2)
                        )
                    ]
                )
            ]
        )
    ),
    Match(
        [
            EQ(
                Input("ip4Src"), IPAddr("10.0.0.255")
            )
        ]
    )
)
Beispiel #6
0
                [
                    EQ(
                        Input("ip4Src"),
                        IPAddr("10.0.0.1")
                        ),
                    ]

                ),
            ActionList(
                [
                    Action(
                        [
                            EQ(
                                Output("port_id_out"),
                                Port(2)
                                )
                            ]
                        )
                    ]
                )
            )
        )

inv2 = Invariant(
            Implies(
            Match(

                [
                    EQ(
                        Input("ip4Src"),