14 class ASTAction(Enum):
22 def __init__(self, action, left, right=None):
24 if action == ASTAction.FALSE or action == ASTAction.TRUE:
25 assert left is None and right is None
29 assert action == ASTAction.EXPR or action == ASTAction.NOT
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:
42 if self.action == ASTAction.TRUE:
44 if self.action == ASTAction.EXPR:
45 return self.left.write(expr_param, expr_param2)
47 def parse_ast(expr, parse_expr):
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))
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))
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))
62 if expr.strip() == "true":
63 return ASTNode(ASTAction.TRUE, None)
64 if expr.strip() == "false":
65 return ASTNode(ASTAction.FALSE, None)
67 if expr.startswith("!"):
68 return ASTNode(ASTAction.NOT, parse_ast(expr[1:], parse_expr))
70 return parse_expr(expr)
73 class NumbersAction(Enum):
80 def __init__(self, action, val):
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
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]))
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)
111 if expr.startswith("= "):
113 return ASTNode(ASTAction.EXPR, NumbersExpr(NumbersAction.EQ, expr))
115 class FragExpr(Enum):
121 def write(self, ipproto, _param2):
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)"
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)"
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)
158 def __init__(self, val):
164 def write(self, param, _param2):
165 return f"({param} & {self.mask}) == {self.match}"
167 def parse_bit_expr(expr):
168 return ASTNode(ASTAction.EXPR, BitExpr(expr))
171 def ip_to_rule(proto, inip, ty, offset):
173 assert offset is None
174 net = ipaddress.IPv4Network(inip.strip())
175 if net.prefixlen == 0:
177 return f"""if ((ip->{ty} & MASK4({net.prefixlen})) != BIGEND32({int(net.network_address)}ULL))
180 net = ipaddress.IPv6Network(inip.strip())
181 if net.prefixlen == 0:
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]
188 mask = f"MASK6({net.prefixlen})"
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}))
194 def fragment_to_rule(ipproto, rules):
195 ast = parse_ast(rules, parse_frag_expr)
196 return "if (!( " + ast.write(ipproto) + " )) break;"
198 def len_to_rule(rules):
199 ast = parse_ast(rules, parse_numbers_expr)
200 return "if (!( " + ast.write("(data_end - pktdata)") + " )) break;"
202 def proto_to_rule(ipproto, proto):
203 ast = parse_ast(proto, parse_numbers_expr)
206 return "if (!( " + ast.write("ip->protocol") + " )) break;"
208 return "if (!( " + ast.write("ip6->nexthdr") + " )) break;"
210 def icmp_type_to_rule(proto, ty):
211 ast = parse_ast(ty, parse_numbers_expr)
213 return "if (icmp == NULL) break;\nif (!( " + ast.write("icmp->type") + " )) break;"
215 return "if (icmpv6 == NULL) break;\nif (!( " + ast.write("icmpv6->icmp6_type") + " )) break;"
217 def icmp_code_to_rule(proto, code):
218 ast = parse_ast(code, parse_numbers_expr)
220 return "if (icmp == NULL) break;\nif (!( " + ast.write("icmp->code") + " )) break;"
222 return "if (icmpv6 == NULL) break;\nif (!( " + ast.write("icmpv6->icmp6_code") + " )) break;"
224 def dscp_to_rule(proto, rules):
225 ast = parse_ast(rules, parse_numbers_expr)
228 return "if (!( " + ast.write("((ip->tos & 0xfc) >> 2)") + " )) break;"
230 return "if (!( " + ast.write("((ip6->priority << 4) | ((ip6->flow_lbl[0] & 0xc0) >> 4) >> 2)") + " )) break;"
232 def port_to_rule(ty, rules):
234 ast = parse_ast(rules, parse_numbers_expr)
235 return "if (tcp == NULL && udp == NULL) break;\nif (!( " + ast.write("sport", "dport") + " )) break;"
237 ast = parse_ast(rules, parse_numbers_expr)
238 return "if (tcp == NULL && udp == NULL) break;\nif (!( " + ast.write(ty) + " )) break;"
240 def tcp_flags_to_rule(rules):
241 ast = parse_ast(rules, parse_bit_expr)
243 return f"""if (tcp == NULL) break;
244 if (!( {ast.write("(ntohs(tcp->flags) & 0xfff)")} )) break;"""
246 def flow_label_to_rule(rules):
247 ast = parse_ast(rules, parse_bit_expr)
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;"""
252 with open("rules.h", "w") as out:
253 parse = argparse.ArgumentParser()
254 parse.add_argument("--ihl", dest="ihl", required=True, choices=["drop-options","accept-options","parse-options"])
255 parse.add_argument("--v6frag", dest="v6frag", required=True, choices=["drop-frags","ignore","parse-frags","ignore-parse-if-rule"])
256 parse.add_argument("--8021q", dest="vlan", required=True, choices=["drop-vlan","accept-vlan","parse-vlan"])
257 parse.add_argument("--require-8021q", dest="vlan_tag")
258 args = parse.parse_args(sys.argv[1:])
260 if args.ihl == "drop-options":
261 out.write("#define PARSE_IHL XDP_DROP\n")
262 elif args.ihl == "accept-options":
263 out.write("#define PARSE_IHL XDP_PASS\n")
264 elif args.ihl == "parse-options":
265 out.write("#define PARSE_IHL PARSE\n")
267 if args.v6frag == "drop-frags":
268 out.write("#define PARSE_V6_FRAG XDP_DROP\n")
269 elif args.v6frag == "ignore":
271 elif args.v6frag == "parse-frags":
272 out.write("#define PARSE_V6_FRAG PARSE\n")
274 if args.vlan == "drop-vlan":
275 out.write("#define PARSE_8021Q XDP_DROP\n")
276 elif args.vlan == "accept-vlan":
277 out.write("#define PARSE_8021Q XDP_PASS\n")
278 elif args.vlan == "parse-vlan":
279 out.write("#define PARSE_8021Q PARSE\n")
281 if args.vlan_tag is not None:
282 if args.vlan != "parse-vlan":
284 out.write("#define REQ_8021Q " + args.vlan_tag + "\n")
291 out.write("#define RULES \\\n")
294 out.write("\t\t" + r.replace("\n", " \\\n\t\t") + " \\\n")
296 for line in sys.stdin.readlines():
300 if t[0].strip() == "flow4":
303 out.write("if (eth_proto == htons(ETH_P_IP)) { \\\n")
304 out.write("\tdo {\\\n")
305 elif t[0].strip() == "flow6":
308 out.write("if (eth_proto == htons(ETH_P_IPV6)) { \\\n")
309 out.write("\tdo {\\\n")
313 rule = t[1].split("}")[0].strip()
314 for step in rule.split(";"):
315 if step.strip().startswith("src") or step.strip().startswith("dst"):
316 nets = step.strip()[3:].strip().split(" ")
318 assert nets[1] == "offset"
322 if step.strip().startswith("src"):
323 write_rule(ip_to_rule(proto, nets[0], "saddr", offset))
325 write_rule(ip_to_rule(proto, nets[0], "daddr", offset))
326 elif step.strip().startswith("proto") and proto == 4:
327 write_rule(proto_to_rule(4, step.strip()[6:]))
328 elif step.strip().startswith("next header") and proto == 6:
329 write_rule(proto_to_rule(6, step.strip()[12:]))
330 elif step.strip().startswith("icmp type"):
331 write_rule(icmp_type_to_rule(proto, step.strip()[10:]))
332 elif step.strip().startswith("icmp code"):
333 write_rule(icmp_code_to_rule(proto, step.strip()[10:]))
334 elif step.strip().startswith("sport") or step.strip().startswith("dport") or step.strip().startswith("port"):
335 write_rule(port_to_rule(step.strip().split(" ")[0], step.strip().split(" ", 1)[1]))
336 elif step.strip().startswith("length"):
337 write_rule(len_to_rule(step.strip()[7:]))
338 elif step.strip().startswith("dscp"):
339 write_rule(dscp_to_rule(proto, step.strip()[5:]))
340 elif step.strip().startswith("tcp flags"):
341 write_rule(tcp_flags_to_rule(step.strip()[10:]))
342 elif step.strip().startswith("label"):
343 write_rule(flow_label_to_rule(step.strip()[6:]))
344 elif step.strip().startswith("fragment"):
347 write_rule(fragment_to_rule(proto, step.strip()[9:]))
348 elif step.strip() == "":
352 out.write(f"\t\tconst uint32_t ruleidx = STATIC_RULE_CNT + {rulecnt};\\\n")
353 out.write("\t\tDO_RETURN(ruleidx, XDP_DROP);\\\n")
354 out.write("\t} while(0);\\\n}\\\n")
358 out.write(f"#define RULECNT {rulecnt}\n")
360 out.write("#define NEED_V4_PARSE\n")
362 out.write("#define NEED_V6_PARSE\n")
363 if args.v6frag == "ignore-parse-if-rule":
365 out.write("#define PARSE_V6_FRAG PARSE\n")