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 established,related accept comment "!fw4: Allow inbound established and related flows"
 119 {% if (fw4.default_option("drop_invalid")): %}
 120                 ct state invalid drop comment "!fw4: Drop flows with invalid conntrack state"
 121 {% endif %}
 122 {% if (fw4.default_option("synflood_protect") && fw4.default_option("synflood_rate")): %}
 123                 tcp flags & (fin | syn | rst | ack) == syn jump syn_flood comment "!fw4: Rate limit TCP syn packets"
 124 {% endif %}
 125 {% for (let rule in fw4.rules("input")): %}
 126                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 127 {% endfor %}
 128 {% for (let zone in fw4.zones()): for (let rule in zone.match_rules): %}
 129                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "input" }) %}
 130 {% endfor; endfor %}
 131 {% if (fw4.input_policy() == "reject"): %}
 132                 jump handle_reject
 133 {% endif %}
 134 {% fw4.includes('chain-append', 'input') %}
 135         }
 136
 137         chain forward {
 138                 type filter hook forward priority filter; policy {{ fw4.forward_policy(true) }};
 139
 140 {% if (length(flowtable_devices) > 0): %}
 141                 meta l4proto { tcp, udp } flow offload @ft;
 142 {% endif %}
 143 {% fw4.includes('chain-prepend', 'forward') %}
 144                 ct state established,related accept comment "!fw4: Allow forwarded established and related flows"
 145 {% if (fw4.default_option("drop_invalid")): %}
 146                 ct state invalid drop comment "!fw4: Drop flows with invalid conntrack state"
 147 {% endif %}
 148 {% for (let rule in fw4.rules("forward")): %}
 149                 {%+ include("rule.uc", { fw4, zone: (rule.src?.zone?.log_limit ? rule.src.zone : rule.dest?.zone), rule }) %}
 150 {% endfor %}
 151 {% for (let zone in fw4.zones()): for (let rule in zone.match_rules): %}
 152                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "forward" }) %}
 153 {% endfor; endfor %}
 154 {% fw4.includes('chain-append', 'forward') %}
 155 {% if (fw4.forward_policy() == "reject"): %}
 156                 jump handle_reject
 157 {% endif %}
 158         }
 159
 160         chain output {
 161                 type filter hook output priority filter; policy {{ fw4.output_policy(true) }};
 162
 163                 oifname "lo" accept comment "!fw4: Accept traffic towards loopback"
 164
 165 {% fw4.includes('chain-prepend', 'output') %}
 166                 ct state established,related accept comment "!fw4: Allow outbound established and related flows"
 167 {% if (fw4.default_option("drop_invalid")): %}
 168                 ct state invalid drop comment "!fw4: Drop flows with invalid conntrack state"
 169 {% endif %}
 170 {% for (let rule in fw4.rules("output")): %}
 171                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 172 {% endfor %}
 173 {% for (let zone in fw4.zones()): %}
 174 {%  for (let rule in zone.match_rules): %}
 175 {%   if (zone.dflags.helper): %}
 176 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, true); %}
 177 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, true); %}
 178 {%    if (devices_pos || subnets_pos): %}
 179                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "helper" }) %}
 180 {%    endif %}
 181 {%   endif %}
 182                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "output" }) %}
 183 {%  endfor %}
 184 {% endfor %}
 185 {% fw4.includes('chain-append', 'output') %}
 186 {% if (fw4.output_policy() == "reject"): %}
 187                 jump handle_reject
 188 {% endif %}
 189         }
 190
 191         chain prerouting {
 192                 type filter hook prerouting priority filter; policy accept;
 193 {% for (let zone in fw4.zones()): %}
 194 {%  if (zone.dflags.helper): %}
 195 {%   for (let rule in zone.match_rules): %}
 196 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, false); %}
 197 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, false); %}
 198 {%    if (rule.devices_neg || rule.subnets_neg || devices_pos || subnets_pos): %}
 199                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "helper" }) %}
 200 {%    endif %}
 201 {%   endfor %}
 202 {%  endif %}
 203 {% endfor %}
 204         }
 205
 206         chain handle_reject {
 207                 meta l4proto tcp reject with {{
 208                         (fw4.default_option("tcp_reject_code") != "tcp-reset")
 209                                 ? `icmpx type ${fw4.default_option("tcp_reject_code")}`
 210                                 : "tcp reset"
 211                 }} comment "!fw4: Reject TCP traffic"
 212                 reject with {{
 213                         (fw4.default_option("any_reject_code") != "tcp-reset")
 214                                 ? `icmpx type ${fw4.default_option("any_reject_code")}`
 215                                 : "tcp reset"
 216                 }} comment "!fw4: Reject any other traffic"
 217         }
 218
 219 {% if (fw4.default_option("synflood_protect") && fw4.default_option("synflood_rate")):
 220         let r = fw4.default_option("synflood_rate");
 221         let b = fw4.default_option("synflood_burst");
 222 %}
 223         chain syn_flood {
 224                 limit rate {{ r.rate }}/{{ r.unit }}
 225                 {%- if (b): %} burst {{ b }} packets{% endif %} return comment "!fw4: Accept SYN packets below rate-limit"
 226                 drop comment "!fw4: Drop excess packets"
 227         }
 228
 229 {% endif %}
 230 {% for (let zone in fw4.zones()): %}
 231         chain input_{{ zone.name }} {
 232 {%  fw4.includes('chain-prepend', `input_${zone.name}`) %}
 233 {%  for (let rule in fw4.rules(`input_${zone.name}`)): %}
 234                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 235 {%  endfor %}
 236 {%  if (zone.dflags.dnat): %}
 237                 ct status dnat accept comment "!fw4: Accept port redirections"
 238 {%  endif %}
 239 {%  fw4.includes('chain-append', `input_${zone.name}`) %}
 240                 jump {{ zone.input }}_from_{{ zone.name }}
 241         }
 242
 243         chain output_{{ zone.name }} {
 244 {%  fw4.includes('chain-prepend', `output_${zone.name}`) %}
 245 {%  for (let rule in fw4.rules(`output_${zone.name}`)): %}
 246                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 247 {%  endfor %}
 248 {%  fw4.includes('chain-append', `output_${zone.name}`) %}
 249                 jump {{ zone.output }}_to_{{ zone.name }}
 250         }
 251
 252         chain forward_{{ zone.name }} {
 253 {%  fw4.includes('chain-prepend', `forward_${zone.name}`) %}
 254 {%  for (let rule in fw4.rules(`forward_${zone.name}`)): %}
 255                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 256 {%  endfor %}
 257 {%  if (zone.dflags.dnat): %}
 258                 ct status dnat accept comment "!fw4: Accept port forwards"
 259 {%  endif %}
 260 {%  fw4.includes('chain-append', `forward_${zone.name}`) %}
 261                 jump {{ zone.forward }}_to_{{ zone.name }}
 262 {%  if (fw4.forward_policy() != "accept" && (zone.log & 1)): %}
 263                 {%+ if (zone.log_limit): %}limit name "{{ zone.name }}.log_limit" {%+ endif -%}
 264                 log prefix "{{ fw4.forward_policy() }} {{ zone.name }} forward: "
 265 {%  endif %}
 266         }
 267
 268 {%  if (zone.dflags.helper): %}
 269         chain helper_{{ zone.name }} {
 270 {%   for (let rule in fw4.rules(`helper_${zone.name}`)): %}
 271                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 272 {%   endfor %}
 273         }
 274
 275 {%  endif %}
 276 {%  for (let verdict in ["accept", "reject", "drop"]): %}
 277 {%   if (zone.sflags[verdict]): %}
 278         chain {{ verdict }}_from_{{ zone.name }} {
 279 {%    for (let rule in zone.match_rules): %}
 280                 {%+ include("zone-verdict.uc", { fw4, zone, rule, egress: false, verdict }) %}
 281 {%    endfor %}
 282         }
 283
 284 {%   endif %}
 285 {%   if (zone.dflags[verdict]): %}
 286         chain {{ verdict }}_to_{{ zone.name }} {
 287 {%   for (let rule in zone.match_rules): %}
 288 {%     if (verdict == "accept" && (zone.masq || zone.masq6) && !zone.masq_allow_invalid): %}
 289                 {%+ include("zone-drop-invalid.uc", { fw4, zone, rule }) %}
 290 {%     endif %}
 291                 {%+ include("zone-verdict.uc", { fw4, zone, rule, egress: true, verdict }) %}
 292 {%   endfor %}
 293         }
 294
 295 {%   endif %}
 296 {%  endfor %}
 297 {% endfor %}
 298
 299         #
 300         # NAT rules
 301         #
 302
 303         chain dstnat {
 304                 type nat hook prerouting priority dstnat; policy accept;
 305 {% fw4.includes('chain-prepend', 'dstnat') %}
 306 {% for (let zone in fw4.zones()): %}
 307 {%  if (zone.dflags.dnat): %}
 308 {%   for (let rule in zone.match_rules): %}
 309                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "dstnat" }) %}
 310 {%   endfor %}
 311 {%  endif %}
 312 {% endfor %}
 313 {% fw4.includes('chain-append', 'dstnat') %}
 314         }
 315
 316         chain srcnat {
 317                 type nat hook postrouting priority srcnat; policy accept;
 318 {% fw4.includes('chain-prepend', 'srcnat') %}
 319 {% for (let redirect in fw4.redirects("srcnat")): %}
 320                 {%+ include("redirect.uc", { fw4, zone: null, redirect }) %}
 321 {% endfor %}
 322 {% for (let zone in fw4.zones()): %}
 323 {%  if (zone.dflags.snat): %}
 324 {%   for (let rule in zone.match_rules): %}
 325                 {%+ include("zone-jump.uc", { fw4, zone, rule, direction: "srcnat" }) %}
 326 {%   endfor %}
 327 {%  endif %}
 328 {% endfor %}
 329 {% fw4.includes('chain-append', 'srcnat') %}
 330         }
 331
 332 {% for (let zone in fw4.zones()): %}
 333 {%  if (zone.dflags.dnat): %}
 334         chain dstnat_{{ zone.name }} {
 335 {%   fw4.includes('chain-prepend', `dstnat_${zone.name}`) %}
 336 {%   for (let redirect in fw4.redirects(`dstnat_${zone.name}`)): %}
 337                 {%+ include("redirect.uc", { fw4, zone, redirect }) %}
 338 {%   endfor %}
 339 {%   fw4.includes('chain-append', `dstnat_${zone.name}`) %}
 340         }
 341
 342 {%  endif %}
 343 {%  if (zone.dflags.snat): %}
 344         chain srcnat_{{ zone.name }} {
 345 {%   fw4.includes('chain-prepend', `srcnat_${zone.name}`) %}
 346 {%   for (let redirect in fw4.redirects(`srcnat_${zone.name}`)): %}
 347                 {%+ include("redirect.uc", { fw4, zone, redirect }) %}
 348 {%   endfor %}
 349 {%   if (zone.masq): %}
 350 {%    for (let saddrs in zone.masq4_src_subnets): %}
 351 {%     for (let daddrs in zone.masq4_dest_subnets): %}
 352                 {%+ include("zone-masq.uc", { fw4, zone, family: 4, saddrs, daddrs }) %}
 353 {%     endfor %}
 354 {%    endfor %}
 355 {%   endif %}
 356 {%   if (zone.masq6): %}
 357 {%    for (let saddrs in zone.masq6_src_subnets): %}
 358 {%     for (let daddrs in zone.masq6_dest_subnets): %}
 359                 {%+ include("zone-masq.uc", { fw4, zone, family: 6, saddrs, daddrs }) %}
 360 {%     endfor %}
 361 {%    endfor %}
 362 {%   endif %}
 363 {%   fw4.includes('chain-append', `srcnat_${zone.name}`) %}
 364         }
 365
 366 {%  endif %}
 367 {% endfor %}
 368
 369         #
 370         # Raw rules (notrack)
 371         #
 372
 373         chain raw_prerouting {
 374                 type filter hook prerouting priority raw; policy accept;
 375 {% for (let zone in fw4.zones()): %}
 376 {%  if (zone.dflags["notrack"]): %}
 377 {%   for (let rule in zone.match_rules): %}
 378 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, false); %}
 379 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, false); %}
 380 {%    if (rule.devices_neg || rule.subnets_neg || devices_pos || subnets_pos): %}
 381                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "notrack" }) %}
 382 {%    endif %}
 383 {%   endfor %}
 384 {%  endif %}
 385 {% endfor %}
 386 {% fw4.includes('chain-append', 'raw_prerouting') %}
 387         }
 388
 389         chain raw_output {
 390                 type filter hook output priority raw; policy accept;
 391 {% fw4.includes('chain-prepend', 'raw_output') %}
 392 {% for (let zone in fw4.zones()): %}
 393 {%  if (zone.dflags["notrack"]): %}
 394 {%   for (let rule in zone.match_rules): %}
 395 {%    let devices_pos = fw4.filter_loopback_devs(rule.devices_pos, true); %}
 396 {%    let subnets_pos = fw4.filter_loopback_addrs(rule.subnets_pos, true); %}
 397 {%    if (devices_pos || subnets_pos): %}
 398                 {%+ include("zone-jump.uc", { fw4, zone, rule: { ...rule, devices_pos, subnets_pos }, direction: "notrack" }) %}
 399 {%    endif %}
 400 {%   endfor %}
 401 {%  endif %}
 402 {% endfor %}
 403 {% fw4.includes('chain-append', 'raw_output') %}
 404         }
 405
 406 {% for (let zone in fw4.zones()): %}
 407 {%   if (zone.dflags.notrack): %}
 408         chain notrack_{{ zone.name }} {
 409 {% for (let rule in fw4.rules(`notrack_${zone.name}`)): %}
 410                 {%+ include("rule.uc", { fw4, zone, rule }) %}
 411 {% endfor %}
 412         }
 413
 414 {%   endif %}
 415 {% endfor %}
 416
 417         #
 418         # Mangle rules
 419         #
 420
 421         chain mangle_prerouting {
 422                 type filter hook prerouting priority mangle; policy accept;
 423 {% fw4.includes('chain-prepend', 'mangle_prerouting') %}
 424 {% for (let rule in fw4.rules("mangle_prerouting")): %}
 425                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 426 {% endfor %}
 427 {% fw4.includes('chain-append', 'mangle_prerouting') %}
 428         }
 429
 430         chain mangle_postrouting {
 431                 type filter hook postrouting priority mangle; policy accept;
 432 {% fw4.includes('chain-prepend', 'mangle_postrouting') %}
 433 {% for (let rule in fw4.rules("mangle_postrouting")): %}
 434                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 435 {% endfor %}
 436 {% fw4.includes('chain-append', 'mangle_postrouting') %}
 437         }
 438
 439         chain mangle_input {
 440                 type filter hook input priority mangle; policy accept;
 441 {% fw4.includes('chain-prepend', 'mangle_input') %}
 442 {% for (let rule in fw4.rules("mangle_input")): %}
 443                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 444 {% endfor %}
 445 {% fw4.includes('chain-append', 'mangle_input') %}
 446         }
 447
 448         chain mangle_output {
 449                 type route hook output priority mangle; policy accept;
 450 {% fw4.includes('chain-prepend', 'mangle_output') %}
 451 {% for (let rule in fw4.rules("mangle_output")): %}
 452                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 453 {% endfor %}
 454 {% fw4.includes('chain-append', 'mangle_output') %}
 455         }
 456
 457         chain mangle_forward {
 458                 type filter hook forward priority mangle; policy accept;
 459 {% fw4.includes('chain-prepend', 'mangle_forward') %}
 460 {% for (let rule in fw4.rules("mangle_forward")): %}
 461                 {%+ include("rule.uc", { fw4, zone: null, rule }) %}
 462 {% endfor %}
 463 {% for (let zone in fw4.zones()): %}
 464 {%  if (zone.mtu_fix): %}
 465 {%   for (let rule in zone.match_rules): %}
 466                 {%+ include("zone-mssfix.uc", { fw4, zone, rule, egress: false }) %}
 467                 {%+ include("zone-mssfix.uc", { fw4, zone, rule, egress: true }) %}
 468 {%   endfor %}
 469 {%  endif %}
 470 {% endfor %}
 471 {% fw4.includes('chain-append', 'mangle_forward') %}
 472         }
 473 {% fw4.includes('table-append') %}
 474 }
 475 {% fw4.includes('ruleset-append') %}