SSZcreate/Pentab_server / .agents/skills/cybersecurity/skills/deploying-tailscale-for-zero-trust-vpn
deploying-tailscale-for-zero-trust-vpn
FlaggedDeploys and configures Tailscale (or self-hosted Headscale) as a WireGuard-based zero trust mesh VPN, setting up identity-aware ACLs, exit nodes, subnet routers, and MagicDNS for encrypted peer-to-peer connectivity. Use when replacing traditional VPN servers with an identity-authenticated mesh network or enforcing granular per-device access control lists.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 11.0 KB |
| SKILL.md | skill md | 11.3 KB |
| assets/template.md | markdown | 2.3 KB |
| references/api-reference.md | markdown | 1.8 KB |
| references/standards.md | markdown | 1.9 KB |
| references/workflows.md | markdown | 3.3 KB |
| scripts/agent.py | script | 5.0 KB |
| scripts/process.py | script | 11.6 KB |
scripts/process.py
View on GitHub#!/usr/bin/env python3
"""
Tailscale Zero Trust VPN Management and Monitoring.
Manages Tailscale deployment, ACL generation, network health monitoring,
and compliance reporting for zero trust mesh VPN infrastructure.
"""
import json
import subprocess
import datetime
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional
@dataclass
class TailscaleNode:
hostname: str
ip4: str
ip6: str = ""
os: str = ""
online: bool = False
tags: list = field(default_factory=list)
key_expiry: str = ""
last_seen: str = ""
exit_node: bool = False
subnet_routes: list = field(default_factory=list)
@dataclass
class ACLRule:
action: str # "accept" or "deny"
src: list
dst: list
description: str = ""
@dataclass
class ACLGroup:
name: str
members: list
class TailscaleACLGenerator:
"""Generate and validate Tailscale ACL configurations."""
def __init__(self):
self.groups: dict[str, list] = {}
self.tag_owners: dict[str, list] = {}
self.acls: list[dict] = []
self.ssh_rules: list[dict] = []
self.auto_approvers: dict = {"routes": {}, "exitNode": []}
self.node_attrs: list[dict] = []
def add_group(self, name: str, members: list):
if not name.startswith("group:"):
name = f"group:{name}"
self.groups[name] = members
def add_tag(self, tag: str, owners: list):
if not tag.startswith("tag:"):
tag = f"tag:{tag}"
self.tag_owners[tag] = owners
def add_acl_rule(self, src: list, dst: list, action: str = "accept"):
self.acls.append({"action": action, "src": src, "dst": dst})
def add_ssh_rule(self, src: list, dst: list, users: list, action: str = "check"):
self.ssh_rules.append({
"action": action,
"src": src,
"dst": dst,
"users": users,
})
def add_auto_approver_route(self, cidr: str, approvers: list):
self.auto_approvers["routes"][cidr] = approvers
def add_auto_approver_exit_node(self, approvers: list):
self.auto_approvers["exitNode"] = approvers
def generate_policy(self) -> dict:
policy = {}
if self.groups:
policy["groups"] = self.groups
if self.tag_owners:
policy["tagOwners"] = self.tag_owners
if self.acls:
policy["acls"] = self.acls
if self.ssh_rules:
policy["ssh"] = self.ssh_rules
if self.auto_approvers["routes"] or self.auto_approvers["exitNode"]:
policy["autoApprovers"] = self.auto_approvers
if self.node_attrs:
policy["nodeAttrs"] = self.node_attrs
return policy
def export_policy(self, output_path: str):
policy = self.generate_policy()
path = Path(output_path)
path.parent.mkdir(parents=True, exist_ok=True)
with open(path, "w") as f:
json.dump(policy, f, indent=2)
return policy
def validate_policy(self) -> list:
"""Validate ACL policy for common issues."""
issues = []
policy = self.generate_policy()
# Check for empty ACLs
if not policy.get("acls"):
issues.append("WARNING: No ACL rules defined - all traffic will be denied")
# Check for overly permissive rules
for i, rule in enumerate(self.acls):
if "*" in rule.get("src", []) and "*" in rule.get("dst", []):
issues.append(f"CRITICAL: Rule {i} allows all-to-all access")
for dst in rule.get("dst", []):
if dst.endswith(":*"):
issues.append(f"WARNING: Rule {i} allows all ports to {dst}")
# Check groups reference valid members
for group_name, members in self.groups.items():
if not members:
issues.append(f"WARNING: Group {group_name} has no members")
# Check tag owners exist
for tag, owners in self.tag_owners.items():
for owner in owners:
if owner.startswith("group:") and owner not in self.groups:
issues.append(f"ERROR: Tag {tag} references undefined group {owner}")
# Check SSH rules
for i, rule in enumerate(self.ssh_rules):
if "root" in rule.get("users", []) and rule.get("action") != "check":
issues.append(f"WARNING: SSH rule {i} allows root access without re-auth check")
return issues
class TailscaleMonitor:
"""Monitor Tailscale network health and compliance."""
def __init__(self):
self.nodes: list[TailscaleNode] = []
def get_status(self) -> dict:
"""Get current Tailscale status via CLI."""
try:
result = subprocess.run(
["tailscale", "status", "--json"],
capture_output=True, text=True, timeout=10
)
if result.returncode == 0:
return json.loads(result.stdout)
except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
pass
return {}
def parse_nodes(self, status: dict) -> list[TailscaleNode]:
"""Parse Tailscale status into node objects."""
self.nodes = []
peers = status.get("Peer", {})
for peer_id, peer_data in peers.items():
node = TailscaleNode(
hostname=peer_data.get("HostName", "unknown"),
ip4=peer_data.get("TailscaleIPs", [""])[0] if peer_data.get("TailscaleIPs") else "",
ip6=peer_data.get("TailscaleIPs", ["", ""])[1] if len(peer_data.get("TailscaleIPs", [])) > 1 else "",
os=peer_data.get("OS", ""),
online=peer_data.get("Online", False),
tags=peer_data.get("Tags", []),
key_expiry=peer_data.get("KeyExpiry", ""),
last_seen=peer_data.get("LastSeen", ""),
exit_node=peer_data.get("ExitNode", False),
)
self.nodes.append(node)
return self.nodes
def check_health(self) -> dict:
"""Run health checks on the tailnet."""
report = {
"timestamp": datetime.datetime.now().isoformat(),
"total_nodes": len(self.nodes),
"online_nodes": sum(1 for n in self.nodes if n.online),
"offline_nodes": sum(1 for n in self.nodes if not n.online),
"expiring_keys": [],
"untagged_nodes": [],
"exit_nodes": [],
"issues": [],
}
for node in self.nodes:
# Check for expiring keys
if node.key_expiry:
try:
expiry = datetime.datetime.fromisoformat(node.key_expiry.replace("Z", "+00:00"))
days_until = (expiry - datetime.datetime.now(datetime.timezone.utc)).days
if days_until < 30:
report["expiring_keys"].append({
"hostname": node.hostname,
"expires_in_days": days_until,
})
except (ValueError, TypeError):
pass
# Check for untagged nodes
if not node.tags:
report["untagged_nodes"].append(node.hostname)
# Track exit nodes
if node.exit_node:
report["exit_nodes"].append(node.hostname)
# Generate issues
if report["offline_nodes"] > 0:
report["issues"].append(
f"{report['offline_nodes']} nodes offline"
)
if report["expiring_keys"]:
report["issues"].append(
f"{len(report['expiring_keys'])} nodes with keys expiring within 30 days"
)
if report["untagged_nodes"]:
report["issues"].append(
f"{len(report['untagged_nodes'])} nodes without tags (ungoverned by ACLs)"
)
return report
def generate_compliance_report(self) -> dict:
"""Generate zero trust compliance report for the tailnet."""
report = {
"report_date": datetime.datetime.now().isoformat(),
"zero_trust_checks": {
"encryption": {
"status": "PASS",
"detail": "All connections use WireGuard end-to-end encryption",
},
"identity_based_access": {
"status": "PASS" if all(n.tags for n in self.nodes) else "FAIL",
"detail": "All nodes should have identity tags for ACL enforcement",
},
"least_privilege": {
"status": "REVIEW",
"detail": "ACL policy review required - validate minimum necessary access",
},
"continuous_verification": {
"status": "PASS" if not any(
n.key_expiry == "" for n in self.nodes
) else "WARNING",
"detail": "Key expiry should be enabled for all non-server nodes",
},
"device_trust": {
"status": "REVIEW",
"detail": "Verify device authorization and Network Lock status",
},
},
}
return report
def generate_example_policy():
"""Generate an example zero trust ACL policy for Tailscale."""
gen = TailscaleACLGenerator()
# Define groups
gen.add_group("engineering", ["eng1@company.com", "eng2@company.com"])
gen.add_group("sre", ["sre1@company.com", "sre2@company.com"])
gen.add_group("security", ["sec1@company.com"])
gen.add_group("management", ["mgr1@company.com"])
# Define tags
gen.add_tag("production", ["group:sre"])
gen.add_tag("staging", ["group:engineering", "group:sre"])
gen.add_tag("development", ["group:engineering"])
gen.add_tag("database", ["group:sre"])
gen.add_tag("monitoring", ["group:sre", "group:security"])
gen.add_tag("ci-runner", ["group:sre"])
# ACL rules - zero trust, least privilege
gen.add_acl_rule(
src=["group:engineering"],
dst=["tag:development:*", "tag:staging:443,8080"]
)
gen.add_acl_rule(
src=["group:sre"],
dst=["tag:production:22,443,8080", "tag:staging:*", "tag:database:5432,3306"]
)
gen.add_acl_rule(
src=["group:security"],
dst=["tag:monitoring:443,9090", "tag:production:443"]
)
gen.add_acl_rule(
src=["tag:ci-runner"],
dst=["tag:staging:443,8080", "tag:production:443"]
)
# SSH rules with re-authentication
gen.add_ssh_rule(
src=["group:sre"],
dst=["tag:production"],
users=["admin"],
action="check" # Requires re-auth, records session
)
gen.add_ssh_rule(
src=["group:engineering"],
dst=["tag:development"],
users=["autogroup:nonroot"],
action="accept"
)
# Auto-approvers for subnet routes
gen.add_auto_approver_route("10.0.0.0/16", ["group:sre"])
gen.add_auto_approver_exit_node(["group:sre"])
# Validate
issues = gen.validate_policy()
if issues:
print("Policy Validation Issues:")
for issue in issues:
print(f" - {issue}")
else:
print("Policy validation: PASSED")
# Export
policy = gen.export_policy("tailscale_acl_policy.json")
print(f"\nGenerated ACL policy with:")
print(f" Groups: {len(gen.groups)}")
print(f" Tags: {len(gen.tag_owners)}")
print(f" ACL Rules: {len(gen.acls)}")
print(f" SSH Rules: {len(gen.ssh_rules)}")
print(f"\nPolicy saved to: tailscale_acl_policy.json")
print(f"\nPolicy preview:")
print(json.dumps(policy, indent=2))
if __name__ == "__main__":
generate_example_policy()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |