_ Git - flowspec-xdp/blob - genrules.py

   1 #!/usr/bin/env python3
   2
   3 import sys
   4 import ipaddress
   5 from enum import Enum
   6 import argparse
   7
   8
   9 IP_PROTO_ICMP = 1
  10 IP_PROTO_ICMPV6 = 58
  11 IP_PROTO_TCP = 6
  12 IP_PROTO_UDP = 17
  13
  14 class ASTAction(Enum):
  15     OR = 1
  16     AND = 2
  17     NOT = 3
  18     FALSE = 4
  19     TRUE = 5
  20     EXPR = 6
  21 class ASTNode:
  22     def __init__(self, action, left, right=None):
  23         self.action = action
  24         if action == ASTAction.FALSE or action == ASTAction.TRUE:
  25             assert left is None and right is None
  26             return
  27         self.left = left
  28         if right is None:
  29             assert action == ASTAction.EXPR or action == ASTAction.NOT
  30         else:
  31             self.right = right
  32
  33     def write(self, expr_param, expr_param2=None):
  34         if self.action == ASTAction.OR:
  35             return "(" + self.left.write(expr_param, expr_param2) + ") || (" + self.right.write(expr_param, expr_param2) + ")"
  36         if self.action == ASTAction.AND:
  37             return "(" + self.left.write(expr_param, expr_param2) + ") && (" + self.right.write(expr_param, expr_param2) + ")"
  38         if self.action == ASTAction.NOT:
  39             return "!(" + self.left.write(expr_param, expr_param2) + ")"
  40         if self.action == ASTAction.FALSE:
  41             return "0"
  42         if self.action == ASTAction.TRUE:
  43             return "1"
  44         if self.action == ASTAction.EXPR:
  45             return self.left.write(expr_param, expr_param2)
  46
  47 def parse_ast(expr, parse_expr):
  48     expr = expr.strip()
  49
  50     comma_split = expr.split(",", 1)
  51     or_split = expr.split("||", 1)
  52     if len(comma_split) > 1 and not "||" in comma_split[0]:
  53         return ASTNode(ASTAction.OR, parse_ast(comma_split[0], parse_expr), parse_ast(comma_split[1], parse_expr))
  54     if len(or_split) > 1:
  55         assert not "," in or_split[0]
  56         return ASTNode(ASTAction.OR, parse_ast(or_split[0], parse_expr), parse_ast(or_split[1], parse_expr))
  57
  58     and_split = expr.split("&&", 1)
  59     if len(and_split) > 1:
  60         return ASTNode(ASTAction.AND, parse_ast(and_split[0], parse_expr), parse_ast(and_split[1], parse_expr))
  61
  62     if expr.strip() == "true":
  63         return ASTNode(ASTAction.TRUE, None)
  64     if expr.strip() == "false":
  65         return ASTNode(ASTAction.FALSE, None)
  66
  67     if expr.startswith("!"):
  68         return ASTNode(ASTAction.NOT, parse_ast(expr[1:], parse_expr))
  69
  70     return parse_expr(expr)
  71
  72
  73 class NumbersAction(Enum):
  74     EQ = "=="
  75     GT = ">"
  76     GTOE = ">="
  77     LT = "<"
  78     LTOE = "<="
  79 class NumbersExpr:
  80     def __init__(self, action, val):
  81         self.action = action
  82         self.val = val
  83
  84     def write(self, param, param2):
  85         if param2 is not None:
  86             return "(" + param + self.action.value + self.val + ") || (" + param2 + self.action.value + self.val + ")"
  87         return param + self.action.value + self.val
  88
  89 def parse_numbers_expr(expr):
  90     space_split = expr.split(" ")
  91     if expr.startswith(">="):
  92         assert len(space_split) == 2
  93         return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.GTOE, space_split[1]))
  94     if expr.startswith(">"):
  95         assert len(space_split) == 2
  96         return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.GT, space_split[1]))
  97     if expr.startswith("<="):
  98         assert len(space_split) == 2
  99         return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.LTOE, space_split[1]))
 100     if expr.startswith("<"):
 101         assert len(space_split) == 2
 102         return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.LT, space_split[1]))
 103     if ".." in expr:
 104         rangesplit = expr.split("..")
 105         assert len(rangesplit) == 2
 106         #XXX: Are ranges really inclusive,inclusive?
 107         left = ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.GTOE, rangesplit[0]))
 108         right = ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.LTOE, rangesplit[1]))
 109         return ASTNode(ASTAction.AND, left, right)
 110
 111     if expr.startswith("= "):
 112         expr = expr[2:]
 113     return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.EQ, expr))
 114
 115 class FragExpr(Enum):
 116     IF = 1
 117     FF = 2
 118     DF = 3
 119     LF = 4
 120
 121     def write(self, ipproto, _param2):
 122         if ipproto == 4:
 123             if self == FragExpr.IF:
 124                 return "(ip->frag_off & BE16(IP_MF|IP_OFFSET)) != 0"
 125             elif self == FragExpr.FF:
 126                 return "((ip->frag_off & BE16(IP_MF)) != 0 && (ip->frag_off & BE16(IP_OFFSET)) == 0)"
 127             elif self == FragExpr.DF:
 128                 return "(ip->frag_off & BE16(IP_DF)) != 0"
 129             elif self == FragExpr.LF:
 130                 return "((ip->frag_off & BE16(IP_MF)) == 0 && (ip->frag_off & BE16(IP_OFFSET)) != 0)"
 131             else:
 132                 assert False
 133         else:
 134             if self == FragExpr.IF:
 135                 return "frag6 != NULL"
 136             elif self == FragExpr.FF:
 137                 return "(frag6 != NULL && (frag6->frag_off & BE16(IP6_MF)) != 0 && (frag6->frag_off & BE16(IP6_FRAGOFF)) == 0)"
 138             elif self == FragExpr.DF:
 139                 assert False # No such thing in v6
 140             elif self == FragExpr.LF:
 141                 return "(frag6 != NULL && (frag6->frag_off & BE16(IP6_MF)) == 0 && (frag6->frag_off & BE16(IP6_FRAGOFF)) != 0)"
 142             else:
 143                 assert False
 144
 145 def parse_frag_expr(expr):
 146     if expr == "is_fragment":
 147         return ASTNode(ASTAction.EXPR, FragExpr.IF)
 148     elif expr == "first_fragment":
 149         return ASTNode(ASTAction.EXPR, FragExpr.FF)
 150     elif expr == "dont_fragment":
 151         return ASTNode(ASTAction.EXPR, FragExpr.DF)
 152     elif expr == "last_fragment":
 153         return ASTNode(ASTAction.EXPR, FragExpr.LF)
 154     else:
 155         assert False
 156
 157 class BitExpr:
 158     def __init__(self, val):
 159         s = val.split("/")
 160         assert len(s) == 2
 161         self.match = s[0]
 162         self.mask = s[1]
 163
 164     def write(self, param, _param2):
 165         return f"({param} & {self.mask}) == {self.match}"
 166
 167 def parse_bit_expr(expr):
 168     return ASTNode(ASTAction.EXPR, BitExpr(expr))
 169
 170
 171 def ip_to_rule(proto, inip, ty, offset):
 172     if proto == 4:
 173         assert offset is None
 174         net = ipaddress.IPv4Network(inip.strip())
 175         if net.prefixlen == 0:
 176             return ""
 177         return f"""if ((ip->{ty} & MASK4({net.prefixlen})) != BIGEND32({int(net.network_address)}ULL))
 178         break;"""
 179     else:
 180         net = ipaddress.IPv6Network(inip.strip())
 181         if net.prefixlen == 0:
 182             return ""
 183         u32s = [(int(net.network_address) >> (3*32)) & 0xffffffff,
 184                 (int(net.network_address) >> (2*32)) & 0xffffffff,
 185                 (int(net.network_address) >> (1*32)) & 0xffffffff,
 186                 (int(net.network_address) >> (0*32)) & 0xffffffff]
 187         if offset is None:
 188             mask = f"MASK6({net.prefixlen})"
 189         else:
 190             mask = f"MASK6_OFFS({offset}, {net.prefixlen})"
 191         return f"""if ((ip6->{ty} & {mask}) != (BIGEND128({u32s[0]}ULL, {u32s[1]}ULL, {u32s[2]}ULL, {u32s[3]}ULL) & {mask}))
 192         break;"""
 193
 194 def fragment_to_rule(ipproto, rules):
 195     ast = parse_ast(rules, parse_frag_expr)
 196     return "if (!( " + ast.write(ipproto) + " )) break;"
 197
 198 def len_to_rule(rules):
 199     ast = parse_ast(rules, parse_numbers_expr)
 200     return "if (!( " + ast.write("(data_end - pktdata)") + " )) break;"
 201
 202 def proto_to_rule(ipproto, proto):
 203     ast = parse_ast(proto, parse_numbers_expr)
 204
 205     if ipproto == 4:
 206         return "if (!( " + ast.write("ip->protocol") + " )) break;"
 207     else:
 208         return "if (!( " + ast.write("ip6->nexthdr") + " )) break;"
 209
 210 def icmp_type_to_rule(proto, ty):
 211     ast = parse_ast(ty, parse_numbers_expr)
 212     if proto == 4:
 213         return "if (icmp == NULL) break;\nif (!( " + ast.write("icmp->type") + " )) break;"
 214     else:
 215         return "if (icmpv6 == NULL) break;\nif (!( " + ast.write("icmpv6->icmp6_type") + " )) break;"
 216
 217 def icmp_code_to_rule(proto, code):
 218     ast = parse_ast(code, parse_numbers_expr)
 219     if proto == 4:
 220         return "if (icmp == NULL) break;\nif (!( " + ast.write("icmp->code") + " )) break;"
 221     else:
 222         return "if (icmpv6 == NULL) break;\nif (!( " + ast.write("icmpv6->icmp6_code") + " )) break;"
 223
 224 def dscp_to_rule(proto, rules):
 225     ast = parse_ast(rules, parse_numbers_expr)
 226
 227     if proto == 4:
 228         return "if (!( " + ast.write("((ip->tos & 0xfc) >> 2)") + " )) break;"
 229     else:
 230         return "if (!( " + ast.write("((ip6->priority << 2) | ((ip6->flow_lbl[0] & 0xc0) >> 6))") + " )) break;"
 231
 232 def port_to_rule(ty, rules):
 233     if ty == "port" :
 234         ast = parse_ast(rules, parse_numbers_expr)
 235         return "if (!ports_valid) break;\nif (!( " + ast.write("sport", "dport") + " )) break;"
 236
 237     ast = parse_ast(rules, parse_numbers_expr)
 238     return "if (!ports_valid) break;\nif (!( " + ast.write(ty) + " )) break;"
 239
 240 def tcp_flags_to_rule(rules):
 241     ast = parse_ast(rules, parse_bit_expr)
 242
 243     return f"""if (tcp == NULL) break;
 244 if (!( {ast.write("(ntohs(tcp->flags) & 0xfff)")} )) break;"""
 245
 246 def flow_label_to_rule(rules):
 247     ast = parse_ast(rules, parse_bit_expr)
 248
 249     return f"""if (ip6 == NULL) break;
 250 if (!( {ast.write("((((uint32_t)(ip6->flow_lbl[0] & 0xf)) << 2*8) | (((uint32_t)ip6->flow_lbl[1]) << 1*8) | (uint32_t)ip6->flow_lbl[0])")} )) break;"""
 251
 252
 253 with open("rules.h", "w") as out:
 254     parse = argparse.ArgumentParser()
 255     parse.add_argument("--ihl", dest="ihl", required=True, choices=["drop-options","accept-options","parse-options"])
 256     parse.add_argument("--v6frag", dest="v6frag", required=True, choices=["drop-frags","ignore","parse-frags","ignore-parse-if-rule"])
 257     parse.add_argument("--8021q", dest="vlan", required=True, choices=["drop-vlan","accept-vlan","parse-vlan"])
 258     parse.add_argument("--require-8021q", dest="vlan_tag")
 259     args = parse.parse_args(sys.argv[1:])
 260
 261     if args.ihl == "drop-options":
 262         out.write("#define PARSE_IHL XDP_DROP\n")
 263     elif args.ihl == "accept-options":
 264         out.write("#define PARSE_IHL XDP_PASS\n")
 265     elif args.ihl == "parse-options":
 266         out.write("#define PARSE_IHL PARSE\n")
 267
 268     if args.v6frag == "drop-frags":
 269         out.write("#define PARSE_V6_FRAG XDP_DROP\n")
 270     elif args.v6frag == "ignore":
 271         pass
 272     elif args.v6frag == "parse-frags":
 273         out.write("#define PARSE_V6_FRAG PARSE\n")
 274
 275     if args.vlan == "drop-vlan":
 276         out.write("#define PARSE_8021Q XDP_DROP\n")
 277     elif args.vlan == "accept-vlan":
 278         out.write("#define PARSE_8021Q XDP_PASS\n")
 279     elif args.vlan == "parse-vlan":
 280         out.write("#define PARSE_8021Q PARSE\n")
 281
 282     if args.vlan_tag is not None:
 283         if args.vlan != "parse-vlan":
 284             assert False
 285         out.write("#define REQ_8021Q " + args.vlan_tag + "\n")
 286
 287     rules6 = ""
 288     rules4 = ""
 289     use_v6_frags = False
 290     rulecnt = 0
 291
 292     lastrule = None
 293     for line in sys.stdin.readlines():
 294         if "{" in line:
 295             if lastrule is not None:
 296                 print("Skipped rule due to lack of understood community tag: " + lastrule)
 297             lastrule = line
 298             continue
 299         if "BGP.ext_community: " in line:
 300             assert lastrule is not None
 301
 302             t = lastrule.split("{")
 303             if t[0].strip() == "flow4":
 304                 proto = 4
 305                 rules4 += "\tdo {\\\n"
 306             elif t[0].strip() == "flow6":
 307                 proto = 6
 308                 rules6 += "\tdo {\\\n"
 309             else:
 310                 continue
 311
 312             def write_rule(r):
 313                 global rules4, rules6
 314                 if proto == 6:
 315                     rules6 += "\t\t" + r.replace("\n", " \\\n\t\t") + " \\\n"
 316                 else:
 317                     rules4 += "\t\t" + r.replace("\n", " \\\n\t\t") + " \\\n"
 318
 319             rule = t[1].split("}")[0].strip()
 320             for step in rule.split(";"):
 321                 if step.strip().startswith("src") or step.strip().startswith("dst"):
 322                     nets = step.strip()[3:].strip().split(" ")
 323                     if len(nets) > 1:
 324                         assert nets[1] == "offset"
 325                         offset = nets[2]
 326                     else:
 327                         offset = None
 328                     if step.strip().startswith("src"):
 329                         write_rule(ip_to_rule(proto, nets[0], "saddr", offset))
 330                     else:
 331                         write_rule(ip_to_rule(proto, nets[0], "daddr", offset))
 332                 elif step.strip().startswith("proto") and proto == 4:
 333                     write_rule(proto_to_rule(4, step.strip()[6:]))
 334                 elif step.strip().startswith("next header") and proto == 6:
 335                     write_rule(proto_to_rule(6, step.strip()[12:]))
 336                 elif step.strip().startswith("icmp type"):
 337                     write_rule(icmp_type_to_rule(proto, step.strip()[10:]))
 338                 elif step.strip().startswith("icmp code"):
 339                     write_rule(icmp_code_to_rule(proto, step.strip()[10:]))
 340                 elif step.strip().startswith("sport") or step.strip().startswith("dport") or step.strip().startswith("port"):
 341                     write_rule(port_to_rule(step.strip().split(" ")[0], step.strip().split(" ", 1)[1]))
 342                 elif step.strip().startswith("length"):
 343                     write_rule(len_to_rule(step.strip()[7:]))
 344                 elif step.strip().startswith("dscp"):
 345                     write_rule(dscp_to_rule(proto, step.strip()[5:]))
 346                 elif step.strip().startswith("tcp flags"):
 347                     write_rule(tcp_flags_to_rule(step.strip()[10:]))
 348                 elif step.strip().startswith("label"):
 349                     write_rule(flow_label_to_rule(step.strip()[6:]))
 350                 elif step.strip().startswith("fragment"):
 351                     if proto == 6:
 352                         use_v6_frags = True
 353                     write_rule(fragment_to_rule(proto, step.strip()[9:]))
 354                 elif step.strip() == "":
 355                     pass
 356                 else:
 357                     assert False
 358
 359             # Now write the match handling!
 360             first_action = None
 361             last_action = None
 362             for community in line.split("("):
 363                 if not community.startswith("generic, "):
 364                     continue
 365                 blocks = community.split(",")
 366                 assert len(blocks) == 3
 367                 if len(blocks[1].strip()) != 10: # Should be 0x12345678
 368                     continue
 369                 ty = blocks[1].strip()[:6]
 370                 low_bytes = int(blocks[2].strip(") \n"), 16)
 371                 if ty == "0x8006":
 372                     if low_bytes == 0:
 373                         first_action = "return XDP_DROP;"
 374                     else:
 375                         assert False # Not yet supported
 376                 elif ty == "0x8007":
 377                     if low_bytes & 1 == 0:
 378                         last_action = "return XDP_PASS;"
 379                     if low_bytes & 2 == 2:
 380                         write_rule(f"const uint32_t ruleidx = STATIC_RULE_CNT + {rulecnt};")
 381                         write_rule("INCREMENT_MATCH(ruleidx);")
 382                 elif ty == "0x8008":
 383                     assert False # We do not implement the redirect action
 384                 elif ty == "0x8009":
 385                     if low_bytes & ~0b111111 != 0:
 386                         assert False # Invalid DSCP value
 387                     if proto == 4:
 388                         write_rule("int32_t chk = ~BE16(ip->check) & 0xffff;")
 389                         write_rule("uint8_t orig_tos = ip->tos;")
 390                         write_rule("ip->tos = (ip->tos & 3) | " + str(low_bytes << 2) + ";")
 391                         write_rule("chk = (chk - orig_tos + ip->tos);")
 392                         write_rule("if (unlikely(chk < 0)) { chk += 65534; }")
 393                         write_rule("ip->check = ~BE16(chk);")
 394                     else:
 395                         write_rule("ip6->priority = " + str(low_bytes >> 2) + ";")
 396                         write_rule("ip6->flow_lbl[0] = (ip6->flow_lbl[0] & 0x3f) | " + str((low_bytes & 3) << 6) + ";")
 397             if first_action is not None:
 398                 write_rule(first_action)
 399             if last_action is not None:
 400                 write_rule(last_action)
 401             if proto == 6:
 402                 rules6 += "\t} while(0);\\\n"
 403             else:
 404                 rules4 += "\t} while(0);\\\n"
 405             rulecnt += 1
 406             lastrule = None
 407
 408     out.write("\n")
 409     out.write(f"#define RULECNT {rulecnt}\n")
 410     if rules4 != "":
 411         out.write("#define NEED_V4_PARSE\n")
 412         out.write("#define RULES4 {\\\n" + rules4 + "}\n")
 413     if rules6:
 414         out.write("#define NEED_V6_PARSE\n")
 415         out.write("#define RULES6 {\\\n" + rules6 + "}\n")
 416     if args.v6frag == "ignore-parse-if-rule":
 417         if use_v6_frags:
 418             out.write("#define PARSE_V6_FRAG PARSE\n")