root/usr/share/firewall4/templates/ruleset.uc

   1 {%
   2         let flowtable_devices = fw4.resolve_offload_devices();
   3         let available_helpers = filter(fw4.helpers(), h => h.available);
   4         let defined_ipsets = fw4.ipsets();
   5         let zones_with_limits = filter(fw4.zones(), z => z.log_limit);
   6 -%}
   7
   8 table inet fw4
   9 flush table inet fw4
  10 {% if (fw4.check_flowtable()): %}
  11 delete flowtable inet fw4 ft
  12 {% endif %}
  13 {% fw4.includes('ruleset-prepend') %}
  14
  15 table inet fw4 {
  16 {% if (length(flowtable_devices) > 0): %}
  17         #
  18         # Flowtable
  19         #
  20
  21         flowtable ft {
  22                 hook ingress priority 0;
  23                 devices = {{ fw4.set(flowtable_devices, true) }};
  24                 counter;
  25 {% if (fw4.default_option("flow_offloading_hw")): %}
  26                 flags offload;
  27 {% endif %}
  28         }
  29
  30
  31 {% endif %}
  32 {% if (length(available_helpers)): %}
  33         #
  34         # CT helper definitions
  35         #
  36
  37 {%  for (let helper in available_helpers): %}
  38 {%   for (let proto in helper.proto): %}
  39         ct helper {{ helper.name }} {
  40                 type {{ fw4.quote(helper.name, true) }} protocol {{ proto.name }};
  41         }
  42
  43 {%   endfor %}
  44 {%  endfor %}
  45
  46 {% endif %}
  47 {% if (length(defined_ipsets)): %}
  48         #
  49         # Set definitions
  50         #
  51
  52 {%  for (let set in defined_ipsets): %}
  53         set {{ set.name }} {
  54 {%   if (set.comment): %}
  55                 comment {{ fw4.quote(set.comment, true) }}
  56 {%   endif %}
  57                 type {{ fw4.concat(set.types) }}
  58 {%   if (set.maxelem > 0): %}
  59                 size {{ set.maxelem }}
  60 {%   endif %}
  61 {%   if (set.timeout > 0): %}
  62                 timeout {{ set.timeout }}s
  63 {%   endif %}
  64 {%   if (set.interval): %}
  65                 auto-merge
  66 {%   endif %}
  67 {%   if (set.flags): %}
  68                 flags {{ join(',', set.flags) }}
  69 {%   endif %}
  70 {%   fw4.print_setentries(set) %}
  71         }
  72
  73 {%  endfor %}
  74
  75 {% endif %}
  76         #
  77         # Defines
  78         #
  79
  80 {% for (let zone in fw4.zones()): %}
  81         define {{ replace(zone.name, /^[0-9]/, '_$&') }}_devices = {{ fw4.set(zone.match_devices, true) }}
  82         define {{ replace(zone.name, /^[0-9]/, '_$&') }}_subnets = {{ fw4.set(zone.match_subnets, true) }}
  83
  84 {% endfor %}
  85
  86 {% if (length(zones_with_limits)): %}
  87         #
  88         # Limits
  89         #
  90
  91 {%   for (let zone in zones_with_limits): %}
  92         limit {{ zone.name }}.log_limit {
  93                 comment "{{ zone.name }} log limit"
  94                 rate {{ zone.log_limit.rate }}/{{ zone.log_limit.unit }}
  95         }
  96
  97 {%   endfor %}
  98
  99 {% endif %}
 100         #
 101         # User includes
 102         #
 103
 104         include "/etc/nftables.d/*.nft"
 105 {% fw4.includes('table-prepend') %}
 106
 107
 108         #
 109         # Filter rules
 110         #
 111
 112         chain input {
 113                 type filter hook input priority filter; policy {{ fw4.input_policy(true) }};
 114
 115                 iifname "lo" accept comment "!fw4: Accept traffic from loopback"
 116
 117 {% fw4.includes('chain-prepend', 'input') %}
 118                 ct state vmap { established : accept, related : accept{% if (fw4.default_option("drop_invalid")): %}, invalid : drop{% endif %} } comment "!fw4: Handle inbound flows"
 119 {% if (fw4.default_option("synflood_protect") && fw4.default_option("synflood_rate")): %}
 120                 tcp flags & (fin | syn | rst | ack) == syn jump syn_flood comment "!fw4: Rate limit TCP syn packets"
 121 {% endif %}
 122 {% for (let rule in fw4.rules("input")): %}
 123                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 124 {% endfor %}
 125 {% for (let zone in fw4.zones()): for (let rule in zone.match_rules): %}
 126                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "input" }) %}
 127 {% endfor; endfor %}
 128 {% if (fw4.input_policy() == "reject"): %}
 129                 jump handle_reject
 130 {% endif %}
 131 {% fw4.includes('chain-append', 'input') %}
 132         }
 133
 134         chain forward {
 135                 type filter hook forward priority filter; policy {{ fw4.forward_policy(true) }};
 136
 137 {% if (length(flowtable_devices) > 0): %}
 138                 meta l4proto { tcp, udp } flow offload @ft;
 139 {% endif %}
 140 {% fw4.includes('chain-prepend', 'forward') %}
 141                 ct state vmap { established : accept, related : accept{% if (fw4.default_option("drop_invalid")): %}, invalid : drop{% endif %} } comment "!fw4: Handle forwarded flows"
 142 {% for (let rule in fw4.rules("forward")): %}
 143                 {%+ include("rule.uc", { fw4, zone: (rule.src?.zone?.log_limit ? rule.src.zone : rule.dest?.zone), rule }) %}
 144 {% endfor %}
 145 {% for (let zone in fw4.zones()): for (let rule in zone.match_rules): %}
 146                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "forward" }) %}
 147 {% endfor; endfor %}
 148 {% fw4.includes('chain-append', 'forward') %}
 149 {% if (fw4.forward_policy() == "reject"): %}
 150                 jump handle_reject
 151 {% endif %}
 152         }
 153
 154         chain output {
 155                 type filter hook output priority filter; policy {{ fw4.output_policy(true) }};
 156
 157                 oifname "lo" accept comment "!fw4: Accept traffic towards loopback"
 158
 159 {% fw4.includes('chain-prepend', 'output') %}
 160                 ct state vmap { established : accept, related : accept{% if (fw4.default_option("drop_invalid")): %}, invalid : drop{% endif %} } comment "!fw4: Handle outbound flows"
 161 {% for (let rule in fw4.rules("output")): %}
 162                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 163 {% endfor %}
 164 {% for (let zone in fw4.zones()): %}
 165 {%  for (let rule in zone.match_rules): %}
 166 {%   if (zone.dflags.helper): %}
 167 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, true); %}
 168 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, true); %}
 169 {%    if (devices_pos || subnets_pos): %}
 170                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "helper" }) %}
 171 {%    endif %}
 172 {%   endif %}
 173                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "output" }) %}
 174 {%  endfor %}
 175 {% endfor %}
 176 {% fw4.includes('chain-append', 'output') %}
 177 {% if (fw4.output_policy() == "reject"): %}
 178                 jump handle_reject
 179 {% endif %}
 180         }
 181
 182         chain prerouting {
 183                 type filter hook prerouting priority filter; policy accept;
 184 {% for (let zone in fw4.zones()): %}
 185 {%  if (zone.dflags.helper): %}
 186 {%   for (let rule in zone.match_rules): %}
 187 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, false); %}
 188 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, false); %}
 189 {%    if (rule.devices_neg || rule.subnets_neg || devices_pos || subnets_pos): %}
 190                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "helper" }) %}
 191 {%    endif %}
 192 {%   endfor %}
 193 {%  endif %}
 194 {% endfor %}
 195         }
 196
 197         chain handle_reject {
 198                 meta l4proto tcp reject with {{
 199                         (fw4.default_option("tcp_reject_code") != "tcp-reset")
 200                                 ? `icmpx type ${fw4.default_option("tcp_reject_code")}`
 201                                 : "tcp reset"
 202                 }} comment "!fw4: Reject TCP traffic"
 203                 reject with {{
 204                         (fw4.default_option("any_reject_code") != "tcp-reset")
 205                                 ? `icmpx type ${fw4.default_option("any_reject_code")}`
 206                                 : "tcp reset"
 207                 }} comment "!fw4: Reject any other traffic"
 208         }
 209
 210 {% if (fw4.default_option("synflood_protect") && fw4.default_option("synflood_rate")):
 211         let r = fw4.default_option("synflood_rate");
 212         let b = fw4.default_option("synflood_burst");
 213 %}
 214         chain syn_flood {
 215                 limit rate {{ r.rate }}/{{ r.unit }}
 216                 {%- if (b): %} burst {{ b }} packets{% endif %} return comment "!fw4: Accept SYN packets below rate-limit"
 217                 drop comment "!fw4: Drop excess packets"
 218         }
 219
 220 {% endif %}
 221 {% for (let zone in fw4.zones()): %}
 222         chain input_{{ zone.name }} {
 223 {%  fw4.includes('chain-prepend', `input_${zone.name}`) %}
 224 {%  for (let rule in fw4.rules(`input_${zone.name}`)): %}
 225                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 226 {%  endfor %}
 227 {%  if (zone.dflags.dnat): %}
 228                 ct status dnat accept comment "!fw4: Accept port redirections"
 229 {%  endif %}
 230 {%  fw4.includes('chain-append', `input_${zone.name}`) %}
 231                 jump {{ zone.input }}_from_{{ zone.name }}
 232         }
 233
 234         chain output_{{ zone.name }} {
 235 {%  fw4.includes('chain-prepend', `output_${zone.name}`) %}
 236 {%  for (let rule in fw4.rules(`output_${zone.name}`)): %}
 237                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 238 {%  endfor %}
 239 {%  fw4.includes('chain-append', `output_${zone.name}`) %}
 240                 jump {{ zone.output }}_to_{{ zone.name }}
 241         }
 242
 243         chain forward_{{ zone.name }} {
 244 {%  fw4.includes('chain-prepend', `forward_${zone.name}`) %}
 245 {%  for (let rule in fw4.rules(`forward_${zone.name}`)): %}
 246                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 247 {%  endfor %}
 248 {%  if (zone.dflags.dnat): %}
 249                 ct status dnat accept comment "!fw4: Accept port forwards"
 250 {%  endif %}
 251 {%  fw4.includes('chain-append', `forward_${zone.name}`) %}
 252                 jump {{ zone.forward }}_to_{{ zone.name }}
 253 {%  if (fw4.forward_policy() != "accept" && (zone.log & 1)): %}
 254                 {%+ if (zone.log_limit): %}limit name "{{ zone.name }}.log_limit" {%+ endif -%}
 255                 log prefix "{{ fw4.forward_policy() }} {{ zone.name }} forward: "
 256 {%  endif %}
 257         }
 258
 259 {%  if (zone.dflags.helper): %}
 260         chain helper_{{ zone.name }} {
 261 {%   for (let rule in fw4.rules(`helper_${zone.name}`)): %}
 262                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 263 {%   endfor %}
 264         }
 265
 266 {%  endif %}
 267 {%  for (let verdict in ["accept", "reject", "drop"]): %}
 268 {%   if (zone.sflags[verdict]): %}
 269         chain {{ verdict }}_from_{{ zone.name }} {
 270 {%    for (let rule in zone.match_rules): %}
 271                 {%+ include("zone-verdict.uc", { fw4, zone, rule, egress: false, verdict }) %}
 272 {%    endfor %}
 273         }
 274
 275 {%   endif %}
 276 {%   if (zone.dflags[verdict]): %}
 277         chain {{ verdict }}_to_{{ zone.name }} {
 278 {%   for (let rule in zone.match_rules): %}
 279 {%     if (verdict == "accept" && (zone.masq || zone.masq6) && !zone.masq_allow_invalid): %}
 280                 {%+ include("zone-drop-invalid.uc", { fw4, zone, rule }) %}
 281 {%     endif %}
 282                 {%+ include("zone-verdict.uc", { fw4, zone, rule, egress: true, verdict }) %}
 283 {%   endfor %}
 284         }
 285
 286 {%   endif %}
 287 {%  endfor %}
 288 {% endfor %}
 289
 290         #
 291         # NAT rules
 292         #
 293
 294         chain dstnat {
 295                 type nat hook prerouting priority dstnat; policy accept;
 296 {% fw4.includes('chain-prepend', 'dstnat') %}
 297 {% for (let zone in fw4.zones()): %}
 298 {%  if (zone.dflags.dnat): %}
 299 {%   for (let rule in zone.match_rules): %}
 300                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "dstnat" }) %}
 301 {%   endfor %}
 302 {%  endif %}
 303 {% endfor %}
 304 {% fw4.includes('chain-append', 'dstnat') %}
 305         }
 306
 307         chain srcnat {
 308                 type nat hook postrouting priority srcnat; policy accept;
 309 {% fw4.includes('chain-prepend', 'srcnat') %}
 310 {% for (let redirect in fw4.redirects("srcnat")): %}
 311                 {%+ include("redirect.uc", { fw4, zone: null, redirect }) %}
 312 {% endfor %}
 313 {% for (let zone in fw4.zones()): %}
 314 {%  if (zone.dflags.snat): %}
 315 {%   for (let rule in zone.match_rules): %}
 316                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "srcnat" }) %}
 317 {%   endfor %}
 318 {%  endif %}
 319 {% endfor %}
 320 {% fw4.includes('chain-append', 'srcnat') %}
 321         }
 322
 323 {% for (let zone in fw4.zones()): %}
 324 {%  if (zone.dflags.dnat): %}
 325         chain dstnat_{{ zone.name }} {
 326 {%   fw4.includes('chain-prepend', `dstnat_${zone.name}`) %}
 327 {%   for (let redirect in fw4.redirects(`dstnat_${zone.name}`)): %}
 328                 {%+ include("redirect.uc", { fw4, zone, redirect }) %}
 329 {%   endfor %}
 330 {%   fw4.includes('chain-append', `dstnat_${zone.name}`) %}
 331         }
 332
 333 {%  endif %}
 334 {%  if (zone.dflags.snat): %}
 335         chain srcnat_{{ zone.name }} {
 336 {%   fw4.includes('chain-prepend', `srcnat_${zone.name}`) %}
 337 {%   for (let redirect in fw4.redirects(`srcnat_${zone.name}`)): %}
 338                 {%+ include("redirect.uc", { fw4, zone, redirect }) %}
 339 {%   endfor %}
 340 {%   if (zone.masq): %}
 341 {%    for (let saddrs in zone.masq4_src_subnets): %}
 342 {%     for (let daddrs in zone.masq4_dest_subnets): %}
 343                 {%+ include("zone-masq.uc", { fw4, zone, family: 4, saddrs, daddrs }) %}
 344 {%     endfor %}
 345 {%    endfor %}
 346 {%   endif %}
 347 {%   if (zone.masq6): %}
 348 {%    for (let saddrs in zone.masq6_src_subnets): %}
 349 {%     for (let daddrs in zone.masq6_dest_subnets): %}
 350                 {%+ include("zone-masq.uc", { fw4, zone, family: 6, saddrs, daddrs }) %}
 351 {%     endfor %}
 352 {%    endfor %}
 353 {%   endif %}
 354 {%   fw4.includes('chain-append', `srcnat_${zone.name}`) %}
 355         }
 356
 357 {%  endif %}
 358 {% endfor %}
 359
 360         #
 361         # Raw rules (notrack)
 362         #
 363
 364         chain raw_prerouting {
 365                 type filter hook prerouting priority raw; policy accept;
 366 {% for (let zone in fw4.zones()): %}
 367 {%  if (zone.dflags["notrack"]): %}
 368 {%   for (let rule in zone.match_rules): %}
 369 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, false); %}
 370 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, false); %}
 371 {%    if (rule.devices_neg || rule.subnets_neg || devices_pos || subnets_pos): %}
 372                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "notrack" }) %}
 373 {%    endif %}
 374 {%   endfor %}
 375 {%  endif %}
 376 {% endfor %}
 377 {% fw4.includes('chain-append', 'raw_prerouting') %}
 378         }
 379
 380         chain raw_output {
 381                 type filter hook output priority raw; policy accept;
 382 {% fw4.includes('chain-prepend', 'raw_output') %}
 383 {% for (let zone in fw4.zones()): %}
 384 {%  if (zone.dflags["notrack"]): %}
 385 {%   for (let rule in zone.match_rules): %}
 386 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, true); %}
 387 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, true); %}
 388 {%    if (devices_pos || subnets_pos): %}
 389                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "notrack" }) %}
 390 {%    endif %}
 391 {%   endfor %}
 392 {%  endif %}
 393 {% endfor %}
 394 {% fw4.includes('chain-append', 'raw_output') %}
 395         }
 396
 397 {% for (let zone in fw4.zones()): %}
 398 {%   if (zone.dflags.notrack): %}
 399         chain notrack_{{ zone.name }} {
 400 {% for (let rule in fw4.rules(`notrack_${zone.name}`)): %}
 401                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 402 {% endfor %}
 403         }
 404
 405 {%   endif %}
 406 {% endfor %}
 407
 408         #
 409         # Mangle rules
 410         #
 411
 412         chain mangle_prerouting {
 413                 type filter hook prerouting priority mangle; policy accept;
 414 {% fw4.includes('chain-prepend', 'mangle_prerouting') %}
 415 {% for (let rule in fw4.rules("mangle_prerouting")): %}
 416                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 417 {% endfor %}
 418 {% fw4.includes('chain-append', 'mangle_prerouting') %}
 419         }
 420
 421         chain mangle_postrouting {
 422                 type filter hook postrouting priority mangle; policy accept;
 423 {% fw4.includes('chain-prepend', 'mangle_postrouting') %}
 424 {% for (let rule in fw4.rules("mangle_postrouting")): %}
 425                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 426 {% endfor %}
 427 {% fw4.includes('chain-append', 'mangle_postrouting') %}
 428         }
 429
 430         chain mangle_input {
 431                 type filter hook input priority mangle; policy accept;
 432 {% fw4.includes('chain-prepend', 'mangle_input') %}
 433 {% for (let rule in fw4.rules("mangle_input")): %}
 434                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 435 {% endfor %}
 436 {% fw4.includes('chain-append', 'mangle_input') %}
 437         }
 438
 439         chain mangle_output {
 440                 type route hook output priority mangle; policy accept;
 441 {% fw4.includes('chain-prepend', 'mangle_output') %}
 442 {% for (let rule in fw4.rules("mangle_output")): %}
 443                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 444 {% endfor %}
 445 {% fw4.includes('chain-append', 'mangle_output') %}
 446         }
 447
 448         chain mangle_forward {
 449                 type filter hook forward priority mangle; policy accept;
 450 {% fw4.includes('chain-prepend', 'mangle_forward') %}
 451 {% for (let rule in fw4.rules("mangle_forward")): %}
 452                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 453 {% endfor %}
 454 {% for (let zone in fw4.zones()): %}
 455 {%  if (zone.mtu_fix): %}
 456 {%   for (let rule in zone.match_rules): %}
 457                 {%+ include("zone-mssfix.uc", { fw4, zone, rule, egress: false }) %}
 458                 {%+ include("zone-mssfix.uc", { fw4, zone, rule, egress: true }) %}
 459 {%   endfor %}
 460 {%  endif %}
 461 {% endfor %}
 462 {% fw4.includes('chain-append', 'mangle_forward') %}
 463         }
 464 {% fw4.includes('table-append') %}
 465 }
 466 {% fw4.includes('ruleset-append') %}