You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
325 lines
16 KiB
Python
325 lines
16 KiB
Python
"""Execute the production-rendered final readback with real CLI serialization.
|
|
|
|
Only external tools are replaced. The final shell body, nft owner checks and
|
|
tenant-set matcher are the production code.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
from virsh_panel.fabric import (
|
|
FIREWALL_MODE_NATIVE,
|
|
_FABRIC_NFT_VALIDATION_SH,
|
|
_FABRIC_WG_READBACK_SH,
|
|
_BOOT_HELPER,
|
|
_TRANSACTION_SCRIPT,
|
|
_VPC_STATE_LOADER,
|
|
_apply_script,
|
|
_config_text,
|
|
_nft_rules_text,
|
|
parse_fabric_plan,
|
|
)
|
|
|
|
|
|
def _between(text: str, start: str, end: str) -> str:
|
|
begin = text.index(start)
|
|
return text[begin:text.index(end, begin)]
|
|
|
|
|
|
_TOOLS = r'''import json
|
|
import os
|
|
from pathlib import Path
|
|
import sys
|
|
|
|
root = Path(os.environ["VC_FINAL_ROOT"])
|
|
name = Path(sys.argv[0]).name
|
|
args = sys.argv[1:]
|
|
with (root / "calls").open("a", encoding="utf-8") as log:
|
|
log.write(json.dumps([name, *args]) + "\n")
|
|
fixture = json.loads((root / "responses").read_text())
|
|
call = json.dumps([name, *args])
|
|
if call not in fixture:
|
|
print("unexpected test tool invocation", file=sys.stderr)
|
|
raise SystemExit(99)
|
|
if name == "wg" and args == ["pubkey"]:
|
|
if sys.stdin.read() != "test-only-private-identity\n":
|
|
raise SystemExit(98)
|
|
response = fixture[call]
|
|
sys.stdout.write(response["stdout"])
|
|
raise SystemExit(response["status"])
|
|
'''
|
|
|
|
|
|
class FinalFixture:
|
|
def __init__(self, tmp_path: Path, manager: str, peers: int = 1):
|
|
self.root = tmp_path
|
|
self.manager = manager
|
|
self.plan = parse_fabric_plan({
|
|
"fabric_id": "final-readback", "region": "hk",
|
|
"overlay_cidr": "100.64.1.0/24", "revision": 1,
|
|
"nodes": [
|
|
{"host_id": str(index), "overlay_ip": f"100.64.1.{index}",
|
|
"endpoint": f"203.0.113.{index}:51820"}
|
|
for index in range(1, peers + 2)
|
|
],
|
|
})
|
|
self.keys = {
|
|
node.host_id: base64.b64encode(bytes([index]) * 32).decode()
|
|
for index, node in enumerate(self.plan.nodes, 1)
|
|
}
|
|
self.responses: dict[str, dict[str, object]] = {}
|
|
self.routes = ""
|
|
tool = tmp_path / "tool"
|
|
tool.write_text(f"#!{sys.executable}\n" + _TOOLS, encoding="utf-8")
|
|
tool.chmod(0o700)
|
|
for name in ("ip", "wg", "nft"):
|
|
(tmp_path / name).symlink_to(tool)
|
|
(tmp_path / "private").write_text("test-only-private-identity\n")
|
|
(tmp_path / "config").write_text(_config_text(
|
|
self.plan, self.plan.nodes[0], self.keys, FIREWALL_MODE_NATIVE))
|
|
for filename in ("vpc-peers", "vpc-routes", "vpc-tenants"):
|
|
(tmp_path / filename).write_text("")
|
|
|
|
self.respond("nft", ["-s", "list", "table", "inet",
|
|
"virt_cloud_wg_fabric"],
|
|
_nft_rules_text(self.plan.digest))
|
|
self.respond("nft", ["list", "set", "inet", "virt_cloud_wg_fabric",
|
|
"vpc_tenant_ips"],
|
|
"table inet virt_cloud_wg_fabric {\n"
|
|
"\tset vpc_tenant_ips {\n\t\ttype ipv4_addr\n"
|
|
"\t\tflags interval\n\t}\n}\n")
|
|
self.respond("wg", ["show", "wg-fabric0"], "")
|
|
self.respond("wg", ["pubkey"], self.keys["1"] + "\n")
|
|
self.respond("wg", ["show", "wg-fabric0", "public-key"],
|
|
self.keys["1"] + "\n")
|
|
self.respond("wg", ["show", "wg-fabric0", "listen-port"], "51820\n")
|
|
self.respond("ip", ["-o", "link", "show", "dev", "wg-fabric0"],
|
|
"16: wg-fabric0: <POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1420 "
|
|
"qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000\n")
|
|
# ip -o replaces the line break between address and lifetime by a
|
|
# backslash. The entire address record must remain one physical line.
|
|
self.respond("ip", ["-o", "-4", "address", "show", "dev", "wg-fabric0"],
|
|
"16: wg-fabric0 inet 100.64.1.1/32 scope global wg-fabric0\\"
|
|
" valid_lft forever preferred_lft forever\n")
|
|
live_peers = self.plan.nodes[1:]
|
|
self.respond("wg", ["show", "wg-fabric0", "peers"],
|
|
"".join(self.keys[node.host_id] + "\n" for node in live_peers))
|
|
self.respond("wg", ["show", "wg-fabric0", "endpoints"],
|
|
"".join(self.keys[node.host_id] + "\t" + node.endpoint + "\n"
|
|
for node in reversed(live_peers)))
|
|
self.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
|
|
"".join(self.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
|
|
for node in reversed(live_peers)))
|
|
metric = " metric 50" if manager == "networkmanager_nmcli" else ""
|
|
self.routes = "".join(node.overlay_ip + " scope 253" + metric + "\n"
|
|
for node in live_peers)
|
|
self.routes += ("2 100.64.1.1 table 255 proto 2 scope 254 "
|
|
"src 100.64.1.1\n")
|
|
self.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev",
|
|
"wg-fabric0"], self.routes)
|
|
for node in live_peers:
|
|
self.respond("ip", ["route", "get", node.overlay_ip,
|
|
"from", "100.64.1.1"],
|
|
node.overlay_ip + " from 100.64.1.1 dev wg-fabric0 uid 0\n"
|
|
" cache\n")
|
|
def respond(self, tool: str, args: list[str], stdout: str, status: int = 0):
|
|
self.responses[json.dumps([tool, *args])] = {
|
|
"stdout": stdout, "status": status,
|
|
}
|
|
|
|
def add_vpc_member(self):
|
|
key = self.keys["2"]
|
|
(self.root / "vpc-peers").write_text(key + "|10.1.0.3/32\n")
|
|
(self.root / "vpc-tenants").write_text("10.1.0.3/32\n")
|
|
(self.root / "vpc-routes").write_text(
|
|
"10.1.0.3/32|wg-fabric0|100|100.64.1.2|100\n")
|
|
self.respond("nft", ["-s", "list", "table", "inet", "virt_cloud_wg_fabric"],
|
|
_nft_rules_text(self.plan.digest).replace(
|
|
"flags interval;", "flags interval;\n elements = { 10.1.0.3 }", 1))
|
|
self.respond("nft", ["list", "set", "inet", "virt_cloud_wg_fabric", "vpc_tenant_ips"],
|
|
"table inet virt_cloud_wg_fabric {\n\tset vpc_tenant_ips {\n"
|
|
"\t\ttype ipv4_addr\n\t\tflags interval\n"
|
|
"\t\telements = { 10.1.0.3 }\n\t}\n}\n")
|
|
self.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev", "wg-fabric0"],
|
|
self.routes + "10.1.0.3 via 100.64.1.2 table 100 proto 186 metric 100\n")
|
|
|
|
def run(self):
|
|
rendered = _apply_script(
|
|
self.plan, self.plan.nodes[0], self.keys,
|
|
deployment_mode=self.manager, firewall_mode=FIREWALL_MODE_NATIVE)
|
|
final = _between(rendered, "vc_fabric_operation_checkpoint final_readback\n",
|
|
"_txn_state_tmp=$(mktemp")
|
|
final = final.split("\n", 1)[1]
|
|
functions = "\n".join((
|
|
_FABRIC_NFT_VALIDATION_SH,
|
|
_FABRIC_WG_READBACK_SH,
|
|
_between(_TRANSACTION_SCRIPT, "nft_panel_owned() {", "snapshot_file() {"),
|
|
_between(_VPC_STATE_LOADER, "vpc_state_allowed_for_peer() {",
|
|
"vpc_state_route_owned() {"),
|
|
_VPC_STATE_LOADER[_VPC_STATE_LOADER.index("vpc_state_nft_set_matches() {"):],
|
|
))
|
|
env = {**os.environ, "VC_FINAL_ROOT": str(self.root),
|
|
"IFACE": "wg-fabric0", "EXPECTED_DIGEST": self.plan.digest,
|
|
"FIREWALL_MODE": FIREWALL_MODE_NATIVE,
|
|
"MANAGED_PEERS": " ".join(self.keys[n.host_id] for n in self.plan.nodes[1:]),
|
|
"MANAGED_ROUTES": " ".join(n.allowed_ip for n in self.plan.nodes[1:]),
|
|
"KEY": str(self.root / "private"), "CONF": str(self.root / "config"),
|
|
"VPC_PEER_FILE": str(self.root / "vpc-peers"),
|
|
"VPC_ROUTE_FILE": str(self.root / "vpc-routes"),
|
|
"VPC_TENANT_FILE": str(self.root / "vpc-tenants")}
|
|
env.update({name: str(self.root / tool) for name, tool in (
|
|
("WG", "wg"), ("IP", "ip"), ("NFT", "nft"))})
|
|
(self.root / "responses").write_text(json.dumps(self.responses))
|
|
result = subprocess.run(["/bin/sh", "-eu", "-c", functions + "\n" + final],
|
|
capture_output=True, text=True, env=env, check=False)
|
|
assert "unexpected test tool invocation" not in result.stderr
|
|
return result
|
|
|
|
|
|
@pytest.mark.parametrize("manager", ["ifupdown", "networkmanager_nmcli"])
|
|
@pytest.mark.parametrize("peers", [1, 2])
|
|
def test_actual_final_slice_accepts_debian_and_alma_serialization(tmp_path, manager, peers):
|
|
fixture = FinalFixture(tmp_path, manager, peers)
|
|
if manager == "networkmanager_nmcli":
|
|
rules = _nft_rules_text(fixture.plan.digest).replace(
|
|
"hook output priority -100;", "hook output priority dstnat;")
|
|
rules = "\n".join(line.replace(" ", "\t") for line in rules.splitlines()) + "\n"
|
|
fixture.respond("nft", ["-s", "list", "table", "inet",
|
|
"virt_cloud_wg_fabric"], rules)
|
|
result = fixture.run()
|
|
assert result.returncode == 0, result.stderr
|
|
|
|
|
|
@pytest.mark.parametrize("drift", ["nft", "public-key", "listen-port", "down", "address",
|
|
"extra-peer", "endpoint", "allowed", "route", "path"])
|
|
def test_actual_final_slice_rejects_mutable_readback_drift(tmp_path, drift):
|
|
fixture = FinalFixture(tmp_path, "ifupdown")
|
|
key = fixture.keys["2"]
|
|
if drift == "nft":
|
|
fixture.respond("nft", ["-s", "list", "table", "inet", "virt_cloud_wg_fabric"],
|
|
_nft_rules_text(fixture.plan.digest).replace("counter drop", "counter accept", 1))
|
|
elif drift in ("public-key", "listen-port"):
|
|
fixture.respond("wg", ["show", "wg-fabric0", drift], "wrong\n")
|
|
elif drift == "down":
|
|
fixture.respond("ip", ["-o", "link", "show", "dev", "wg-fabric0"],
|
|
"16: wg-fabric0: <POINTOPOINT,NOARP> mtu 1420\n")
|
|
elif drift == "address":
|
|
fixture.respond("ip", ["-o", "-4", "address", "show", "dev", "wg-fabric0"],
|
|
"16: wg-fabric0 inet 100.64.1.1/24 scope global wg-fabric0\n")
|
|
elif drift == "extra-peer":
|
|
fixture.respond("wg", ["show", "wg-fabric0", "peers"], key + "\nforeign\n")
|
|
elif drift == "endpoint":
|
|
fixture.respond("wg", ["show", "wg-fabric0", "endpoints"], key + "\t203.0.113.9:51820\n")
|
|
elif drift == "allowed":
|
|
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"], key + "\t100.64.1.9/32\n")
|
|
elif drift == "route":
|
|
fixture.respond("ip", ["-N", "-o", "route", "show", "table", "all", "dev", "wg-fabric0"],
|
|
fixture.routes + "100.64.1.3 scope link\n")
|
|
elif drift == "path":
|
|
fixture.respond("ip", ["route", "get", "100.64.1.2", "from", "100.64.1.1"],
|
|
"100.64.1.2 from 100.64.1.1 dev br0 uid 0\n cache\n")
|
|
result = fixture.run()
|
|
assert result.returncode in (71, 78), result.stderr
|
|
|
|
|
|
@pytest.mark.parametrize("manager", ["ifupdown", "networkmanager_nmcli"])
|
|
@pytest.mark.parametrize("reverse", [False, True])
|
|
@pytest.mark.parametrize("peers", [1, 2])
|
|
def test_actual_final_slice_accepts_official_multiple_allowed_ips_serialization(tmp_path, manager, reverse, peers):
|
|
fixture = FinalFixture(tmp_path, manager, peers)
|
|
key = fixture.keys["2"]
|
|
fixture.add_vpc_member()
|
|
prefixes = ["100.64.1.2/32", "10.1.0.3/32"]
|
|
if reverse:
|
|
prefixes.reverse()
|
|
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
|
|
key + "\t" + " ".join(prefixes) + "\n" + "".join(
|
|
fixture.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
|
|
for node in fixture.plan.nodes[2:]))
|
|
assert fixture.run().returncode == 0
|
|
|
|
|
|
@pytest.mark.parametrize("drift", ["missing", "extra", "duplicate", "unknown", "multiple-key-fields"])
|
|
def test_actual_final_slice_requires_complete_unique_peer_records(tmp_path, drift):
|
|
fixture = FinalFixture(tmp_path, "ifupdown", 2)
|
|
first, second = fixture.keys["2"], fixture.keys["3"]
|
|
if drift == "missing":
|
|
actual = first + "\n"
|
|
elif drift == "extra":
|
|
actual = first + "\n" + second + "\n" + base64.b64encode(bytes([9]) * 32).decode() + "\n"
|
|
elif drift == "duplicate":
|
|
actual = first + "\n" + second + "\n" + first + "\n"
|
|
elif drift == "unknown":
|
|
actual = first + "\n" + "bad-key\n"
|
|
else:
|
|
actual = first + "\t" + second + "\n"
|
|
fixture.respond("wg", ["show", "wg-fabric0", "peers"], actual)
|
|
assert fixture.run().returncode == 71
|
|
|
|
|
|
@pytest.mark.parametrize("drift", ["wide", "public", "duplicate", "missing", "extra", "csv",
|
|
"malformed", "ipv6", "duplicate-peer", "unknown-peer"])
|
|
def test_actual_final_slice_multiple_allowed_ips_remains_fail_closed(tmp_path, drift):
|
|
fixture = FinalFixture(tmp_path, "ifupdown")
|
|
key = fixture.keys["2"]
|
|
fixture.add_vpc_member()
|
|
values = ["100.64.1.2/32", "10.1.0.3/32"]
|
|
if drift == "wide":
|
|
values[1] = "10.1.0.3/24"
|
|
elif drift == "public":
|
|
values[1] = "203.0.113.9/32"
|
|
elif drift == "duplicate":
|
|
values.append(values[1])
|
|
elif drift == "missing":
|
|
values.pop()
|
|
elif drift == "extra":
|
|
values.append("10.1.0.4/32")
|
|
elif drift == "malformed":
|
|
values[1] = "10.1.0.256/32"
|
|
elif drift == "ipv6":
|
|
values[1] = "fd00::3/128"
|
|
actual = key + "\t" + ("," if drift == "csv" else " ").join(values) + "\n"
|
|
if drift == "duplicate-peer":
|
|
actual += actual
|
|
elif drift == "unknown-peer":
|
|
actual += base64.b64encode(bytes([9]) * 32).decode() + "\t10.1.0.9/32\n"
|
|
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"], actual)
|
|
assert fixture.run().returncode == 71
|
|
|
|
|
|
@pytest.mark.parametrize("peers", [1, 2])
|
|
@pytest.mark.parametrize("reverse", [False, True])
|
|
@pytest.mark.parametrize("vpc", [False, True])
|
|
def test_boot_actual_peer_readback_uses_identical_record_validator(tmp_path, peers, reverse, vpc):
|
|
fixture = FinalFixture(tmp_path, "ifupdown", peers)
|
|
if vpc:
|
|
fixture.add_vpc_member()
|
|
fixture.respond("wg", ["show", "wg-fabric0", "allowed-ips"],
|
|
fixture.keys["2"] + "\t10.1.0.3/32 100.64.1.2/32\n" + "".join(
|
|
fixture.keys[node.host_id] + "\t" + node.allowed_ip + "\n"
|
|
for node in fixture.plan.nodes[2:]))
|
|
live_keys = [fixture.keys[node.host_id] for node in fixture.plan.nodes[1:]]
|
|
if reverse:
|
|
live_keys.reverse()
|
|
fixture.respond("wg", ["show", "wg-fabric0", "peers"], "\n".join(live_keys) + "\n")
|
|
(tmp_path / "responses").write_text(json.dumps(fixture.responses))
|
|
peer_body = _between(_BOOT_HELPER, 'actual_peers=$("$WG" show "$IFACE" peers',
|
|
"actual_fabric_routes=")
|
|
allowed = _between(_VPC_STATE_LOADER, "vpc_state_allowed_for_peer() {",
|
|
"vpc_state_route_owned() {")
|
|
result = subprocess.run(["/bin/sh", "-eu", "-c", _FABRIC_WG_READBACK_SH + "\n" + allowed + "\n" + peer_body],
|
|
capture_output=True, text=True, check=False,
|
|
env={**os.environ, "VC_FINAL_ROOT": str(tmp_path),
|
|
"WG": str(tmp_path / "wg"), "IFACE": "wg-fabric0",
|
|
"seen_peers": " ".join(live_keys),
|
|
"CONF": str(tmp_path / "config"),
|
|
"VPC_PEER_FILE": str(tmp_path / "vpc-peers")})
|
|
assert result.returncode == 0, result.stderr
|