This is how Albgott decides who's allowed in.
Not a policy document — the actual rules a connection has to clear before it reaches anything. /system covers what's deployed; this is what decides who's allowed to touch it, work in progress included.
The default posture
Everything else on this page is a variation of one rule: traffic between managed networks is denied by default, and every exception is an explicit, named rule — a source, a destination, a port. Nothing is reachable because two things happen to share a network; it's reachable because a rule for exactly that flow exists on the router.
That applies to the router itself, not just what passes through it. Direct access is limited to established connections, the two VPN tunnels, admin access from an explicit allow-list, and ICMP — everything else is dropped before it's even considered.
| Allowed input to the router | Source | Port / protocol |
|---|---|---|
| Established/related/untracked | Existing connections | any |
| WireGuard (wg-corp) | WAN | udp, not published |
| WireGuard (wg-admin) | WAN | udp, not published |
| Admin access | admin-access-nets | 22, 80, 443/tcp |
| ICMP | any accepted path | icmp |
Everything else: dropped — invalid traffic first, then a default input drop.
Outbound isn't locked down the same way: managed networks get general internet egress by design, because CI needs to pull dependencies and hosts need to reach update servers, and allow-listing every legitimate destination wasn't worth the cost. Inbound is a strict allow-list; outbound is a deliberate exception to that same rule.
Nothing is reachable because two things happen to share a network. It's reachable because a rule for exactly that flow was written down.
That's the network perimeter. Every host enforces its own baseline too, before it's trusted to run anything: key-only SSH, no root login, no password fallback — the same bootstrap every machine goes through on /operations, applied for consistency as much as for security.
Getting in remotely
Remote access runs over two separate WireGuard tunnels rather than one VPN with permission tiers: wg-corp for normal use, wg-admin for infrastructure administration. Neither joins a VLAN directly — a connecting device gets an address on a routed overlay, and the router filters on that address exactly like it would any other network.
The split is about who's on the other end as much as what they can reach. I collaborate with people who aren't me, and wg-corp is what they connect through — it reaches internal tools and nothing past that. wg-admin is the only path to the infrastructure control plane, and no collaborator ever gets it. A compromised device on wg-corp cannot reach a hypervisor console; that's the entire point of the split.
A peer is a device, not a person — my phone and laptop are two separate peers even though both are "me," which is what makes revocation precise: lose one device, disable one peer, everything else keeps working. If a key is ever suspected compromised, the answer is always a new peer, never reusing the old one.
wg-corp → internal apps allowed as needed
wg-corp → Proxmox / router denied by default
wg-admin → management systems allowed as needed
wg-admin → internal apps allowed only when usefulIllustrative addressing below — not the real ranges.
| Tunnel | Subnet | Endpoint | Purpose |
|---|---|---|---|
| wg-corp | 10.20.30.0/24 | Single WAN endpoint, not published | Normal remote access — internal apps, dashboards, docs |
| wg-admin | 10.20.99.0/24 | Single WAN endpoint, not published | Privileged access — Proxmox, router, switch, iDRAC |
Worth calling out: a successful WireGuard handshake only means the device reached the router — it says nothing about what that device is then allowed to do. That's deliberately layered, not collapsed into one check:
| Layer | Decides |
|---|---|
| WireGuard | Whether the device can build the encrypted tunnel at all |
| Client routes (AllowedIPs) | Which destination networks even enter the tunnel |
| Router firewall | Which source/destination/port combinations are allowed |
| DNS | Which names resolve to internal addresses in the first place |
| Application auth | Whether the now-authenticated user may use the app they reached |
That last row is the handoff into the next section — a VPN tunnel gets a device onto the right path, it's the application layer that decides whether the person on the other end of it is actually who they say they are.
Who you are once you're in
Two identity providers exist and both work today, for different reasons. Authentik is the long-term target — everything on this platform is meant to eventually authenticate through it. Zitadel exists for a narrower, forward-looking reason: it's ready for whenever a public-facing app needs its own identity layer, with real multi-tenant support (isolated users, projects, and settings per organization) built in from the start.
What's genuinely still in progress is which services actually sit behind Authentik SSO — today that's the observability stack, with MFA enforced on top through an authenticator app. The rest isn't purely a backlog problem: some services' SSO integrations only exist on a paid tier, a real constraint on rollout speed, not just something left undone. Identity here is a real, working piece of the platform and an unfinished one, and both are true at once.
| Service | What it is | Reached via | Status |
|---|---|---|---|
| Authentik | Primary identity provider — the long-term target for everything | Internal proxy only | Live; observability stack today, MFA via authenticator app |
| Zitadel | Secondary identity provider — multi-tenant, held for future public apps | Public proxy | Live; not yet in production use |
Where secrets live
Infisical runs as a real, reachable secrets-management service, internal only — the goal is simple: stop keeping credentials in plaintext inside config and compose files scattered across hosts, and give them one managed home instead.
Migration is deliberate and ongoing, not finished: deciding which secrets move, then updating what consumes them to treat Infisical as the source of truth only once it actually is one. This matters most exactly where it's riskiest to get wrong — CI. Build agents sit in their own isolated network segment with narrow, explicit outbound rules, and nothing lets a compromised build reach anything management-plane.
Watching for trouble
Security and observability aren't separate stacks here — the same monitoring covered on /operations is also what would notice most access-related problems first. Active checks run from outside the network as well as inside it, so a misconfiguration shows up independently of whatever the metrics pipeline reports. Alerts route to a single phone, with criticals firing faster and duplicate warnings for the same host suppressed — a real problem gets heard once, loudly, not scattered across systems.
The honest gap: none of this is purpose-built security monitoring. There's no dedicated alerting today for repeated failed logins, unusual VPN peer activity, or firewall rule drift — general observability would likely catch a lot of that incidentally, but "would probably notice" and "is explicitly watching for it" are different claims, and this page means to keep being honest about which one is actually true.
What's still open
Consolidating the honesty from every section above into one place, because burying gaps across five subsections would defeat the point of having this page at all.
There's no off-node backup system for this platform today. If a host is ever compromised badly enough to need rebuilding from scratch, there's no tested restore path to fall back on — recovery today means reconstructing from documentation, not restoring from a known-good backup. Tracked on /operations; repeating it here because it's a security fact as much as an operational one.
Authentik and Zitadel both work today, but not everything authenticates through them yet. Rollout is deliberate and ongoing, service by service.
Infisical is real and reachable, but not every credential on this platform lives there yet — some are still sitting in config files on hosts, exactly the thing Infisical exists to replace.
General observability exists and is genuinely useful, but there's no purpose-built alerting today for authentication anomalies, VPN peer activity, or firewall rule drift.
None of this is here to alarm — a security page that only lists what's locked down and skips what isn't would be marketing, not documentation. See /system for what's actually deployed, /operations for how it's kept running day to day.