next if $line =~m/^#/;
next if ($line =~m/^\s*$/);
- if ($line =~ m!^(\S+)\s+(\S+)/(tcp|udp).*$!) {
+ if ($line =~ m!^(\S+)\s+(\S+)/(tcp|udp|sctp).*$!) {
$services->{byid}->{$2}->{name} = $1;
$services->{byid}->{$2}->{port} = $2;
$services->{byid}->{$2}->{$3} = 1;
return $etc_services;
}
-my $etc_protocols;
-
-sub get_etc_protocols {
- return $etc_protocols if $etc_protocols;
-
- my $filename = "/etc/protocols";
+sub parse_protocol_file {
+ my ($filename) = @_;
my $fh = IO::File->new($filename, O_RDONLY);
if (!$fh) {
next if $line =~m/^#/;
next if ($line =~m/^\s*$/);
- if ($line =~ m!^(\S+)\s+(\d+)\s+.*$!) {
+ if ($line =~ m!^(\S+)\s+(\d+)(?:\s+.*)?$!) {
$protocols->{byid}->{$2}->{name} = $1;
$protocols->{byname}->{$1} = $protocols->{byid}->{$2};
}
close($fh);
+ return $protocols;
+}
+
+my $etc_protocols;
+
+sub get_etc_protocols {
+ return $etc_protocols if $etc_protocols;
+
+ my $protocols = parse_protocol_file('/etc/protocols');
+
# add special case for ICMP v6
$protocols->{byid}->{icmpv6}->{name} = "icmpv6";
$protocols->{byname}->{icmpv6} = $protocols->{byid}->{icmpv6};
return $etc_protocols;
}
+my $etc_ethertypes;
+
+sub get_etc_ethertypes {
+ $etc_ethertypes = parse_protocol_file('/etc/ethertypes')
+ if !$etc_ethertypes;
+ return $etc_ethertypes;
+}
+
my $__local_network;
sub local_network {
my @elements = split(/,/, $str);
die "extraneous commas in list\n" if $str ne join(',', @elements);
foreach my $item (@elements) {
- $count++;
if ($item =~ m/^(\d+):(\d+)$/) {
+ $count += 2;
my ($port1, $port2) = ($1, $2);
die "invalid port '$port1'\n" if $port1 > 65535;
die "invalid port '$port2'\n" if $port2 > 65535;
} elsif ($item =~ m/^(\d+)$/) {
+ $count += 1;
my $port = $1;
die "invalid port '$port'\n" if $port > 65535;
} else {
}
}
- die "ICPM ports not allowed in port range\n" if $icmp_port && $count > 1;
+ die "ICPM ports not allowed in port range\n" if $icmp_port && $count > 0;
+
+ # I really don't like to use the word number here, but it's the only thing
+ # that makes sense in a literal way. The range 1:100 counts as 2, not as
+ # one and not as 100...
+ die "too many entries in port list (> 15 numbers)\n"
+ if $count > 15;
- return $count;
+ return (scalar(@elements) > 1);
}
PVE::JSONSchema::register_format('pve-fw-sport-spec', \&pve_fw_verify_sport_spec);
minimum => 0,
optional => 1,
},
+ ebtables => {
+ description => "Enable ebtables rules cluster wide.",
+ type => 'boolean',
+ default => 1,
+ optional => 1,
+ },
policy_in => {
description => "Input policy.",
type => 'string',
run_command("/sbin/ipset restore", input => $cmdlist, errmsg => "ipset_restore_cmdlist");
}
+sub ebtables_restore_cmdlist {
+ my ($cmdlist) = @_;
+
+ run_command("/sbin/ebtables-restore", input => $cmdlist, errmsg => "ebtables_restore_cmdlist");
+}
+
sub iptables_get_chains {
my ($iptablescmd) = @_;
return $res;
}
+sub ebtables_get_chains {
+
+ my $res = {};
+ my $chains = {};
+ my $parser = sub {
+ my $line = shift;
+ return if $line =~ m/^#/;
+ return if $line =~ m/^\s*$/;
+ if ($line =~ m/^:(\S+)\s\S+$/) {
+ # Make sure we know chains exist even if they're empty.
+ $chains->{$1} //= [];
+ } elsif ($line =~ m/^(?:\S+)\s(\S+)\s(?:\S+).*/) {
+ my $chain = $1;
+ $line =~ s/\s+$//;
+ push @{$chains->{$chain}}, $line;
+ } else {
+ # simply ignore the rest
+ return;
+ }
+ };
+
+ run_command("/sbin/ebtables-save", outfunc => $parser);
+ # compute digest for each chain and store rules as well
+ foreach my $chain (keys %$chains) {
+ $res->{$chain}->{rules} = $chains->{$chain};
+ $res->{$chain}->{sig} = iptables_chain_digest($chains->{$chain});
+ }
+ return $res;
+}
+
+# substitude action of rule according to action hash
+sub rule_substitude_action {
+ my ($rule, $actions) = @_;
+
+ if (my $action = $rule->{action}) {
+ $rule->{action} = $actions->{$action} if defined($actions->{$action});
+ }
+}
+
# generate a src or dst match
# $dir(ection) is either d or s
sub ipt_gen_src_or_dst_match {
if (my $proto = $rule->{proto}) {
push @match, "-p $proto";
- my $nbdport = defined($rule->{dport}) ? parse_port_name_number_or_range($rule->{dport}, 1) : 0;
- my $nbsport = defined($rule->{sport}) ? parse_port_name_number_or_range($rule->{sport}, 0) : 0;
-
- my $multiport = 0;
- $multiport++ if $nbdport > 1;
- $multiport++ if $nbsport > 1;
+ my $multidport = defined($rule->{dport}) && parse_port_name_number_or_range($rule->{dport}, 1);
+ my $multisport = defined($rule->{sport}) && parse_port_name_number_or_range($rule->{sport}, 0);
- push @match, "--match multiport" if $multiport;
+ my $add_dport = sub {
+ return if !$rule->{dport};
- die "multiport: option '--sports' cannot be used together with '--dports'\n"
- if ($multiport == 2) && ($rule->{dport} ne $rule->{sport});
-
- if ($rule->{dport}) {
if ($proto eq 'icmp') {
# Note: we use dport to store --icmp-type
die "unknown icmp-type '$rule->{dport}'\n"
push @match, "-m icmpv6 --icmpv6-type $rule->{dport}";
} elsif (!$PROTOCOLS_WITH_PORTS->{$proto}) {
die "protocol $proto does not have ports\n";
+ } elsif ($multidport) {
+ push @match, "--match multiport", "--dports $rule->{dport}";
} else {
- if ($nbdport > 1) {
- if ($multiport == 2) {
- push @match, "--ports $rule->{dport}";
- } else {
- push @match, "--dports $rule->{dport}";
- }
- } else {
- push @match, "--dport $rule->{dport}";
- }
+ push @match, "--dport $rule->{dport}";
}
- }
+ };
+
+ my $add_sport = sub {
+ return if !$rule->{sport};
- if ($rule->{sport}) {
die "protocol $proto does not have ports\n"
if !$PROTOCOLS_WITH_PORTS->{$proto};
- if ($nbsport > 1) {
- push @match, "--sports $rule->{sport}" if $multiport != 2;
+ if ($multisport) {
+ push @match, "--match multiport", "--sports $rule->{sport}";
} else {
push @match, "--sport $rule->{sport}";
}
- }
+ };
+
+ # order matters - single port before multiport!
+ $add_dport->() if $multisport;
+ $add_sport->();
+ $add_dport->() if !$multisport;
} elsif ($rule->{dport} || $rule->{sport}) {
die "destination port '$rule->{dport}', but no protocol specified\n" if $rule->{dport};
die "source port '$rule->{sport}', but no protocol specified\n" if $rule->{sport};
return @iptcmds;
}
-sub ruleset_generate_match {
- my ($ruleset, $chain, $ipversion, $rule, $actions, $goto, $cluster_conf, $fw_conf) = @_;
-
- return if defined($rule->{enable}) && !$rule->{enable};
- return if $rule->{errors};
-
- return $rule->{match} if defined $rule->{match};
-
- die "unable to emit macro - internal error" if $rule->{macro}; # should not happen
-
- my $nbdport = defined($rule->{dport}) ? parse_port_name_number_or_range($rule->{dport}, 1) : 0;
- my $nbsport = defined($rule->{sport}) ? parse_port_name_number_or_range($rule->{sport}, 0) : 0;
-
- my @cmd = ();
-
- push @cmd, "-i $rule->{iface_in}" if $rule->{iface_in};
- push @cmd, "-o $rule->{iface_out}" if $rule->{iface_out};
-
- my $source = $rule->{source};
- my $dest = $rule->{dest};
-
- push @cmd, ipt_gen_src_or_dst_match($source, 's', $ipversion, $cluster_conf, $fw_conf) if $source;
- push @cmd, ipt_gen_src_or_dst_match($dest, 'd', $ipversion, $cluster_conf, $fw_conf) if $dest;
-
- if (my $proto = $rule->{proto}) {
- push @cmd, "-p $proto";
-
- my $multiport = 0;
- $multiport++ if $nbdport > 1;
- $multiport++ if $nbsport > 1;
-
- push @cmd, "--match multiport" if $multiport;
-
- die "multiport: option '--sports' cannot be used together with '--dports'\n"
- if ($multiport == 2) && ($rule->{dport} ne $rule->{sport});
-
- if ($rule->{dport}) {
- if ($proto eq 'icmp') {
- # Note: we use dport to store --icmp-type
- die "unknown icmp-type '$rule->{dport}'\n"
- if $rule->{dport} !~ /^\d+$/ && !defined($icmp_type_names->{$rule->{dport}});
- push @cmd, "-m icmp --icmp-type $rule->{dport}";
- } elsif ($proto eq 'icmpv6') {
- # Note: we use dport to store --icmpv6-type
- die "unknown icmpv6-type '$rule->{dport}'\n"
- if $rule->{dport} !~ /^\d+$/ && !defined($icmpv6_type_names->{$rule->{dport}});
- push @cmd, "-m icmpv6 --icmpv6-type $rule->{dport}";
- } elsif (!$PROTOCOLS_WITH_PORTS->{$proto}) {
- die "protocol $proto does not have ports\n";
- } else {
- if ($nbdport > 1) {
- if ($multiport == 2) {
- push @cmd, "--ports $rule->{dport}";
- } else {
- push @cmd, "--dports $rule->{dport}";
- }
- } else {
- push @cmd, "--dport $rule->{dport}";
- }
- }
- }
-
- if ($rule->{sport}) {
- die "protocol $proto does not have ports\n"
- if !$PROTOCOLS_WITH_PORTS->{$proto};
- if ($nbsport > 1) {
- push @cmd, "--sports $rule->{sport}" if $multiport != 2;
- } else {
- push @cmd, "--sport $rule->{sport}";
- }
- }
- } elsif ($rule->{dport} || $rule->{sport}) {
- die "destination port '$rule->{dport}', but no protocol specified\n" if $rule->{dport};
- die "source port '$rule->{sport}', but no protocol specified\n" if $rule->{sport};
- }
-
- push @cmd, "-m addrtype --dst-type $rule->{dsttype}" if $rule->{dsttype};
-
- return scalar(@cmd) ? join(' ', @cmd) : undef;
-}
-
-sub ruleset_generate_action {
- my ($ruleset, $chain, $ipversion, $rule, $actions, $goto, $cluster_conf, $fw_conf) = @_;
-
- return $rule->{target} if defined $rule->{target};
-
- my @cmd = ();
-
- if (my $action = $rule->{action}) {
- $action = $actions->{$action} if defined($actions->{$action});
- $goto = 1 if !defined($goto) && $action eq 'PVEFW-SET-ACCEPT-MARK';
- push @cmd, $goto ? "-g $action" : "-j $action";
- }
-
- return scalar(@cmd) ? join(' ', @cmd) : undef;
-}
-
sub ruleset_generate_rule {
- my ($ruleset, $chain, $ipversion, $rule, $actions, $goto, $cluster_conf, $fw_conf) = @_;
+ my ($ruleset, $chain, $ipversion, $rule, $cluster_conf, $fw_conf) = @_;
my $rules;
}
}
-sub ruleset_generate_rule_old {
- my ($ruleset, $chain, $ipversion, $rule, $actions, $goto, $cluster_conf, $fw_conf) = @_;
-
- my $rules;
-
- if ($rule->{macro}) {
- $rules = &$apply_macro($rule->{macro}, $rule, 0, $ipversion);
- } else {
- $rules = [ $rule ];
- }
-
- # update all or nothing
-
- # fixme: lots of temporary ugliness
- my @mstrs = ();
- my @astrs = ();
- my @logging = ();
- my @logmsg = ();
- foreach my $tmp (@$rules) {
- my $m = ruleset_generate_match($ruleset, $chain, $ipversion, $tmp, $actions, $goto, $cluster_conf, $fw_conf);
- my $a = ruleset_generate_action($ruleset, $chain, $ipversion, $tmp, $actions, $goto, $cluster_conf, $fw_conf);
- if (defined $m or defined $a) {
- push @mstrs, defined($m) ? $m : "";
- push @astrs, defined($a) ? $a : "";
- push @logging, $tmp->{log};
- push @logmsg, $tmp->{logmsg};
- }
- }
-
- for my $i (0 .. $#mstrs) {
- ruleset_addrule($ruleset, $chain, $mstrs[$i], $astrs[$i], $logging[$i], $logmsg[$i]);
- }
-}
-
-sub ruleset_generate_rule_insert {
- my ($ruleset, $chain, $ipversion, $rule, $actions, $goto) = @_;
-
- die "implement me" if $rule->{macro}; # not implemented, because not needed so far
-
- my $match = ruleset_generate_match($ruleset, $chain, $ipversion, $rule, $actions, $goto);
- my $action = ruleset_generate_action($ruleset, $chain, $ipversion, $rule, $actions, $goto);
- if (defined $match && defined $action) {
- ruleset_insertrule($ruleset, $chain, $match, $action);
- }
-}
-
sub ruleset_create_chain {
my ($ruleset, $chain) = @_;
my $logaction = get_log_rule_base($chain, $vmid, $logmsg, $log);
push @{$ruleset->{$chain}}, "-A $chain $match $logaction";
}
- push @{$ruleset->{$chain}}, "-A $chain $match $action";
+ # for stable ebtables digests avoid double-spaces to match ebtables-save output
+ $match .= ' ' if length($match);
+ push @{$ruleset->{$chain}}, "-A $chain ${match}$action";
}
sub ruleset_insertrule {
if ($policy eq 'ACCEPT') {
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, { action => 'ACCEPT' },
- { ACCEPT => $accept_action});
+ my $rule = { action => 'ACCEPT' };
+ rule_substitude_action($rule, { ACCEPT => $accept_action});
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule);
} elsif ($policy eq 'DROP') {
next if $rule->{type} ne $lc_direction;
eval {
if ($direction eq 'OUT') {
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, $rule,
- { ACCEPT => "PVEFW-SET-ACCEPT-MARK", REJECT => "PVEFW-reject" },
- undef, $cluster_conf, $vmfw_conf);
+ rule_substitude_action($rule, { ACCEPT => "PVEFW-SET-ACCEPT-MARK", REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf, $vmfw_conf);
} else {
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, $rule,
- { ACCEPT => $in_accept , REJECT => "PVEFW-reject" },
- undef, $cluster_conf, $vmfw_conf);
+ rule_substitude_action($rule, { ACCEPT => $in_accept , REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf, $vmfw_conf);
}
};
warn $@ if $@;
if ($rule->{type} eq 'group') {
ruleset_add_group_rule($ruleset, $cluster_conf, $chain, $rule, 'IN', $accept_action, $ipversion);
} elsif ($rule->{type} eq 'in') {
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, $rule,
- { ACCEPT => $accept_action, REJECT => "PVEFW-reject" },
- undef, $cluster_conf, $hostfw_conf);
+ rule_substitude_action($rule, { ACCEPT => $accept_action, REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf, $hostfw_conf);
}
};
warn $@ if $@;
if ($rule->{type} eq 'group') {
ruleset_add_group_rule($ruleset, $cluster_conf, $chain, $rule, 'OUT', $accept_action, $ipversion);
} elsif ($rule->{type} eq 'out') {
- ruleset_generate_rule_old($ruleset, $chain, $ipversion,
- $rule, { ACCEPT => $accept_action, REJECT => "PVEFW-reject" },
- undef, $cluster_conf, $hostfw_conf);
+ rule_substitude_action($rule, { ACCEPT => $accept_action, REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf, $hostfw_conf);
}
};
warn $@ if $@;
foreach my $rule (@$rules) {
next if $rule->{type} ne 'in';
+ next if !$rule->{enable} || $rule->{errors};
next if $rule->{ipversion} && $rule->{ipversion} ne $ipversion;
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, $rule,
- { ACCEPT => "PVEFW-SET-ACCEPT-MARK", REJECT => "PVEFW-reject" },
- undef, $cluster_conf);
+ rule_substitude_action($rule, { ACCEPT => "PVEFW-SET-ACCEPT-MARK", REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf);
}
$chain = "GROUP-${group}-OUT";
foreach my $rule (@$rules) {
next if $rule->{type} ne 'out';
+ next if !$rule->{enable} || $rule->{errors};
next if $rule->{ipversion} && $rule->{ipversion} ne $ipversion;
# we use PVEFW-SET-ACCEPT-MARK (Instead of ACCEPT) because we need to
# check also other tap rules later
- ruleset_generate_rule_old($ruleset, $chain, $ipversion, $rule,
- { ACCEPT => 'PVEFW-SET-ACCEPT-MARK', REJECT => "PVEFW-reject" },
- undef, $cluster_conf);
+ rule_substitude_action($rule, { ACCEPT => 'PVEFW-SET-ACCEPT-MARK', REJECT => "PVEFW-reject" });
+ ruleset_generate_rule($ruleset, $chain, $ipversion, $rule, $cluster_conf);
}
}
return $rule;
}
+sub verify_ethertype {
+ my ($value) = @_;
+ my $types = get_etc_ethertypes();
+ die "unknown ethernet protocol type: $value\n"
+ if !defined($types->{byname}->{$value}) &&
+ !defined($types->{byid}->{$value});
+}
+
sub parse_vmfw_option {
my ($line) = @_;
} elsif ($line =~ m/^(ips_queues):\s*((\d+)(:(\d+))?)\s*$/i) {
$opt = lc($1);
$value = $2;
+ } elsif ($line =~ m/^(layer2_protocols):\s*(((\S+)[,]?)+)\s*$/i) {
+ $opt = lc($1);
+ $value = $2;
+ verify_ethertype($_) foreach split(/\s*,\s*/, $value);
} else {
die "can't parse option '$line'\n"
}
if (($value > 1) && ((time() - $value) > 60)) {
$value = 0
}
+ } elsif ($line =~ m/^(ebtables):\s*(0|1)\s*$/i) {
+ $opt = lc($1);
+ $value = int($2);
} elsif ($line =~ m/^(policy_(in|out)):\s*(ACCEPT|DROP|REJECT)\s*$/i) {
$opt = lc($1);
$value = uc($3);
$vmfw_configs = read_vm_firewall_configs($cluster_conf, $vmdata, undef, $verbose);
}
- return ({},{},{}) if !$cluster_conf->{options}->{enable};
+ return ({},{},{},{}) if !$cluster_conf->{options}->{enable};
my $localnet;
if ($cluster_conf->{aliases}->{local_network}) {
my $localnet_ver;
($localnet, $localnet_ver) = parse_ip_or_cidr(local_network() || '127.0.0.0/8');
- $cluster_conf->{aliases}->{local_network} = {
+ $cluster_conf->{aliases}->{local_network} = {
name => 'local_network', cidr => $localnet, ipversion => $localnet_ver };
}
my $ruleset = compile_iptables_filter($cluster_conf, $hostfw_conf, $vmfw_configs, $vmdata, 4, $verbose);
my $rulesetv6 = compile_iptables_filter($cluster_conf, $hostfw_conf, $vmfw_configs, $vmdata, 6, $verbose);
+ my $ebtables_ruleset = compile_ebtables_filter($cluster_conf, $hostfw_conf, $vmfw_configs, $vmdata, $verbose);
my $ipset_ruleset = compile_ipsets($cluster_conf, $vmfw_configs, $vmdata);
- return ($ruleset, $ipset_ruleset, $rulesetv6);
+ return ($ruleset, $ipset_ruleset, $rulesetv6, $ebtables_ruleset);
}
sub compile_iptables_filter {
return $ipset_ruleset;
}
+sub compile_ebtables_filter {
+ my ($cluster_conf, $hostfw_conf, $vmfw_configs, $vmdata, $verbose) = @_;
+
+ if (!($cluster_conf->{options}->{ebtables} // 1)) {
+ return {};
+ }
+
+ my $ruleset = {};
+
+ ruleset_create_chain($ruleset, "PVEFW-FORWARD");
+
+ ruleset_create_chain($ruleset, "PVEFW-FWBR-OUT");
+ #for ipv4 and ipv6, check macaddress in iptables, so we use conntrack 'ESTABLISHED', to speedup rules
+ ruleset_addrule($ruleset, 'PVEFW-FORWARD', '-p IPv4', '-j ACCEPT');
+ ruleset_addrule($ruleset, 'PVEFW-FORWARD', '-p IPv6', '-j ACCEPT');
+ ruleset_addrule($ruleset, 'PVEFW-FORWARD', '-o fwln+', '-j PVEFW-FWBR-OUT');
+
+ # generate firewall rules for QEMU VMs
+ foreach my $vmid (keys %{$vmdata->{qemu}}) {
+ eval {
+ my $conf = $vmdata->{qemu}->{$vmid};
+ my $vmfw_conf = $vmfw_configs->{$vmid};
+ return if !$vmfw_conf;
+
+ foreach my $netid (keys %$conf) {
+ next if $netid !~ m/^net(\d+)$/;
+ my $net = PVE::QemuServer::parse_net($conf->{$netid});
+ next if !$net->{firewall};
+ my $iface = "tap${vmid}i$1";
+ my $macaddr = $net->{macaddr};
+
+ generate_tap_layer2filter($ruleset, $iface, $macaddr, $vmfw_conf, $vmid);
+
+ }
+ };
+ warn $@ if $@; # just to be sure - should not happen
+ }
+
+ # generate firewall rules for LXC containers
+ foreach my $vmid (keys %{$vmdata->{lxc}}) {
+ eval {
+ my $conf = $vmdata->{lxc}->{$vmid};
+
+ my $vmfw_conf = $vmfw_configs->{$vmid};
+ return if !$vmfw_conf || !$vmfw_conf->{options}->{enable};
+
+ foreach my $netid (keys %$conf) {
+ next if $netid !~ m/^net(\d+)$/;
+ my $net = PVE::LXC::Config->parse_lxc_network($conf->{$netid});
+ next if !$net->{firewall};
+ my $iface = "veth${vmid}i$1";
+ my $macaddr = $net->{hwaddr};
+ generate_tap_layer2filter($ruleset, $iface, $macaddr, $vmfw_conf, $vmid);
+ }
+ };
+ warn $@ if $@; # just to be sure - should not happen
+ }
+
+ return $ruleset;
+}
+
+sub generate_tap_layer2filter {
+ my ($ruleset, $iface, $macaddr, $vmfw_conf, $vmid) = @_;
+ my $options = $vmfw_conf->{options};
+
+ my $tapchain = $iface."-OUT";
+
+ # ebtables remove zeros from mac pairs
+ $macaddr =~ s/0([0-9a-f])/$1/ig;
+ $macaddr = lc($macaddr);
+
+ ruleset_create_chain($ruleset, $tapchain);
+
+ if (defined($macaddr) && !(defined($options->{macfilter}) && $options->{macfilter} == 0)) {
+ ruleset_addrule($ruleset, $tapchain, "-s ! $macaddr", '-j DROP');
+ }
+
+ if (defined($options->{layer2_protocols})){
+ foreach my $proto (split(/,/, $options->{layer2_protocols})) {
+ ruleset_addrule($ruleset, $tapchain, "-p $proto", '-j ACCEPT');
+ }
+ ruleset_addrule($ruleset, $tapchain, '', "-j DROP");
+ } else {
+ ruleset_addrule($ruleset, $tapchain, '', '-j ACCEPT');
+ }
+
+ ruleset_addrule($ruleset, 'PVEFW-FWBR-OUT', "-i $iface", "-j $tapchain");
+}
+
+# the parameter $change_only_regex changes two things if defined:
+# * all chains not matching it will be left intact
+# * both the $active_chains hash and the returned status_hash have different
+# structure (they contain a key named 'rules').
sub get_ruleset_status {
- my ($ruleset, $active_chains, $digest_fn, $verbose) = @_;
+ my ($ruleset, $active_chains, $digest_fn, $verbose, $change_only_regex) = @_;
my $statushash = {};
foreach my $chain (sort keys %$ruleset) {
- my $sig = &$digest_fn($ruleset->{$chain});
+ my $rules = $ruleset->{$chain};
+ my $sig = &$digest_fn($rules);
+ my $oldsig;
$statushash->{$chain}->{sig} = $sig;
-
- my $oldsig = $active_chains->{$chain};
+ if (defined($change_only_regex)) {
+ $oldsig = $active_chains->{$chain}->{sig};
+ $statushash->{$chain}->{rules} = $rules;
+ } else {
+ $oldsig = $active_chains->{$chain};
+ }
if (!defined($oldsig)) {
$statushash->{$chain}->{action} = 'create';
} else {
$statushash->{$chain}->{action} = 'update';
}
}
- print "$statushash->{$chain}->{action} $chain ($sig)\n" if $verbose;
- foreach my $cmd (@{$ruleset->{$chain}}) {
- print "\t$cmd\n" if $verbose;
+ if ($verbose) {
+ print "$statushash->{$chain}->{action} $chain ($sig)\n";
+ foreach my $cmd (@{$rules}) {
+ print "\t$cmd\n";
+ }
}
}
foreach my $chain (sort keys %$active_chains) {
- if (!defined($ruleset->{$chain})) {
- my $sig = $active_chains->{$chain};
- $statushash->{$chain}->{action} = 'delete';
- $statushash->{$chain}->{sig} = $sig;
- print "delete $chain ($sig)\n" if $verbose;
+ next if defined($ruleset->{$chain});
+ my $action = 'delete';
+ my $sig = $active_chains->{$chain};
+ if (defined($change_only_regex)) {
+ $action = 'ignore' if ($chain !~ m/$change_only_regex/);
+ $statushash->{$chain}->{rules} = $active_chains->{$chain}->{rules};
+ $sig = $sig->{sig};
}
+ $statushash->{$chain}->{action} = $action;
+ $statushash->{$chain}->{sig} = $sig;
+ print "$action $chain ($sig)\n" if $verbose;
}
return $statushash;
return wantarray ? ($cmdlist, $changes) : $cmdlist;
}
+my $pve_ebtables_chainname_regex = qr/PVEFW-\S+|(?:tap|veth)\d+i\d+-(?:IN|OUT)/;
+
+sub get_ebtables_cmdlist {
+ my ($ruleset, $verbose) = @_;
+
+ my $changes = 0;
+ my $cmdlist = "*filter\n";
+
+ my $active_chains = ebtables_get_chains();
+ my $statushash = get_ruleset_status($ruleset, $active_chains,
+ \&iptables_chain_digest, $verbose,
+ $pve_ebtables_chainname_regex);
+
+ # create chains first and make sure PVE rules are evaluated if active
+ my $append_pve_to_forward = '-A FORWARD -j PVEFW-FORWARD';
+ my $pve_include = 0;
+ foreach my $chain (sort keys %$statushash) {
+ next if ($statushash->{$chain}->{action} eq 'delete');
+ $cmdlist .= ":$chain ACCEPT\n";
+ $pve_include = 1 if ($chain eq 'PVEFW-FORWARD');
+ }
+
+ foreach my $chain (sort keys %$statushash) {
+ my $stat = $statushash->{$chain};
+ next if ($stat->{action} eq 'delete');
+ $changes = 1 if ($stat->{action} !~ 'ignore|exists');
+
+ foreach my $cmd (@{$statushash->{$chain}->{'rules'}}) {
+ if ($chain eq 'FORWARD' && $cmd eq $append_pve_to_forward) {
+ next if ! $pve_include;
+ $pve_include = 0;
+ }
+ $cmdlist .= "$cmd\n";
+ }
+ }
+ $cmdlist .= "$append_pve_to_forward\n" if $pve_include;
+
+ return wantarray ? ($cmdlist, $changes) : $cmdlist;
+}
+
sub get_ipset_cmdlist {
my ($ruleset, $verbose) = @_;
}
sub apply_ruleset {
- my ($ruleset, $hostfw_conf, $ipset_ruleset, $rulesetv6, $verbose) = @_;
+ my ($ruleset, $hostfw_conf, $ipset_ruleset, $rulesetv6, $ebtables_ruleset, $verbose) = @_;
enable_bridge_firewall();
my ($cmdlist, $changes) = get_ruleset_cmdlist($ruleset, $verbose);
my ($cmdlistv6, $changesv6) = get_ruleset_cmdlist($rulesetv6, $verbose, "ip6tables");
+ my ($ebtables_cmdlist, $ebtables_changes) = get_ebtables_cmdlist($ebtables_ruleset, $verbose);
if ($verbose) {
if ($ipset_changes) {
print "ip6tables changes:\n";
print $cmdlistv6;
}
+
+ if ($ebtables_changes) {
+ print "ebtables changes:\n";
+ print $ebtables_cmdlist;
+ }
}
my $tmpfile = "$pve_fw_status_dir/ipsetcmdlist1";
ipset_restore_cmdlist($ipset_delete_cmdlist) if $ipset_delete_cmdlist;
+ ebtables_restore_cmdlist($ebtables_cmdlist);
+
+ $tmpfile = "$pve_fw_status_dir/ebtablescmdlist";
+ PVE::Tools::file_set_contents($tmpfile, $ebtables_cmdlist || '');
+
# test: re-read status and check if everything is up to date
my $active_chains = iptables_get_chains();
my $statushash = get_ruleset_status($ruleset, $active_chains, \&iptables_chain_digest, 0);
}
}
+ my $active_ebtables_chains = ebtables_get_chains();
+ my $ebtables_statushash = get_ruleset_status($ebtables_ruleset,
+ $active_ebtables_chains, \&iptables_chain_digest,
+ 0, $pve_ebtables_chainname_regex);
+
+ foreach my $chain (sort keys %$ebtables_ruleset) {
+ my $stat = $ebtables_statushash->{$chain};
+ if ($stat->{action} ne 'exists') {
+ warn "ebtables : unable to update chain '$chain'\n";
+ $errors = 1;
+ }
+ }
+
die "unable to apply firewall changes\n" if $errors;
update_nf_conntrack_max($hostfw_conf);
my $hostfw_conf = load_hostfw_conf($cluster_conf);
- my ($ruleset, $ipset_ruleset, $rulesetv6) = compile($cluster_conf, $hostfw_conf);
+ my ($ruleset, $ipset_ruleset, $rulesetv6, $ebtables_ruleset) = compile($cluster_conf, $hostfw_conf);
- apply_ruleset($ruleset, $hostfw_conf, $ipset_ruleset, $rulesetv6);
+ apply_ruleset($ruleset, $hostfw_conf, $ipset_ruleset, $rulesetv6, $ebtables_ruleset);
};
run_locked($code);
projects / pve-firewall.git / blobdiff