Initial Homegate 0.4.0 with web UI, Compose and Gitea Actions
Some checks failed
Test and publish Homegate / checks (push) Has been cancelled
Test and publish Homegate / publish (push) Has been cancelled

This commit is contained in:
2026-10-14 01:40:14 +03:00
commit 357daa8915
33 changed files with 4032 additions and 0 deletions

222
sync_ssh.py Normal file
View File

@@ -0,0 +1,222 @@
#!/usr/bin/env python3
"""Download a restricted Homegate SSH config. Requires Python 3.9+, no packages."""
import argparse
import ipaddress
import os
from pathlib import Path
import re
import ssl
import sys
import tempfile
import time
from urllib.parse import urlsplit
from urllib.request import build_opener, ProxyHandler, HTTPSHandler, HTTPRedirectHandler
MAX_BYTES = 512 * 1024
HEADER = "# Homegate SSH config v1"
BEGIN = "# BEGIN HOMEGATE INCLUDE"
END = "# END HOMEGATE INCLUDE"
ALIAS = re.compile(r"[a-z0-9][a-z0-9_.-]{0,252}$")
USER = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_.@-]{0,63}$")
PRIVATE = [ipaddress.ip_network(n) for n in
("10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "fc00::/7")]
def check(ok, message):
if not ok:
raise ValueError(message)
def validate_entry(entry):
check(isinstance(entry, dict) and not set(entry) - {"aliases", "host", "port", "user"},
"Unknown SSH field")
aliases = entry.get("aliases")
check(isinstance(aliases, list) and 0 < len(aliases) <= 16, "SSH aliases must contain 1–16 names")
for alias in aliases:
check(isinstance(alias, str) and ALIAS.fullmatch(alias), "SSH aliases must be literal names; no patterns or tokens")
try:
ipaddress.ip_address(alias)
except ValueError:
pass
else:
raise ValueError("Use an SSH alias, not an IP address, in Host")
check(len(set(aliases)) == len(aliases), "Duplicate SSH alias")
check(isinstance(entry.get("host"), str), "SSH HostName must be an IP string")
address = ipaddress.ip_address(entry["host"])
check(address.version != 6 or address.scope_id is None, "Scoped IPv6 and SSH percent tokens are not allowed")
check(any(address.version == net.version and address in net for net in PRIVATE),
"SSH HostName must be an RFC1918 or ULA address")
check(type(entry.get("port")) is int and 1 <= entry["port"] <= 65535, "Invalid SSH port")
if "user" in entry:
check(isinstance(entry["user"], str) and USER.fullmatch(entry["user"]), "Invalid SSH user")
return entry
def render_ssh(entries):
check(isinstance(entries, list) and len(entries) <= 1024, "Too many SSH hosts")
lines = [HEADER, "# Public connection metadata only. Private keys stay on this computer.", ""]
seen = set()
for entry in entries:
validate_entry(entry)
check(not seen.intersection(entry["aliases"]), "SSH aliases must be unique across all hosts")
seen.update(entry["aliases"])
lines += ["Host " + " ".join(entry["aliases"]), " HostName " + entry["host"],
" Port " + str(entry["port"])]
if "user" in entry:
lines.append(" User " + entry["user"])
lines += [" StrictHostKeyChecking ask", ""]
# Do not leave an included file in its final host's conditional scope.
lines += ["Host *", ""]
result = "\n".join(lines)
check(len(result.encode()) <= MAX_BYTES, "SSH config exceeds size limit")
return result
def validate_download(raw):
"""Never pass arbitrary downloaded SSH directives to ssh (Match exec can execute)."""
check(len(raw) <= MAX_BYTES, "SSH config exceeds size limit")
text = raw.decode("ascii").replace("\r\n", "\n")
check(all(c == "\n" or c == "\t" or 32 <= ord(c) < 127 for c in text), "Control characters in SSH config")
check(text.splitlines()[:1] == [HEADER], "Not a Homegate SSH config")
entries, current, fields = [], None, set()
finished = False
def flush():
if current is not None:
check({"hostname", "port", "stricthostkeychecking"}.issubset(fields), "Incomplete SSH host")
validate_entry(current)
entries.append(current)
for line in text.splitlines()[1:]:
line = line.strip()
if not line or line.startswith("#"):
continue
check(not finished, "Directives after final Host * are forbidden")
parts = line.split()
directive, values = parts[0].lower(), parts[1:]
if directive == "host":
flush()
current, fields = None, set()
if values == ["*"]:
finished = True
else:
current = {"aliases": values}
continue
check(current is not None, "Global directives are forbidden")
check(directive in {"hostname", "port", "user", "stricthostkeychecking"},
"Forbidden SSH directive: " + directive)
check(directive not in fields and len(values) == 1, "Duplicate directive or unexpected arguments")
fields.add(directive)
value = values[0]
if directive == "hostname":
current["host"] = value
elif directive == "port":
check(value.isascii() and value.isdecimal(), "Invalid SSH port")
current["port"] = int(value)
elif directive == "user":
current["user"] = value
else:
check(value == "ask", "Host key verification must remain enabled")
check(finished, "Missing final Host *")
# Rebuild from validated values; don't install source text from the network.
return render_ssh(entries)
class NoRedirect(HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
raise ValueError("Redirects are refused; provide the final /ssh-config URL")
def download(url, ca_file=None):
parsed = urlsplit(url)
check(parsed.scheme in ("http", "https") and parsed.hostname and not parsed.username
and not parsed.password and not parsed.fragment, "Use an HTTP(S) URL without credentials")
context = ssl.create_default_context(cafile=ca_file)
# Ignore HTTP(S)_PROXY for LAN fetches. HTTPS verification cannot be disabled.
opener = build_opener(ProxyHandler({}), HTTPSHandler(context=context), NoRedirect())
with opener.open(url, timeout=15) as response:
check(response.status == 200, "Server did not return HTTP 200")
raw = response.read(MAX_BYTES + 1)
return validate_download(raw)
def atomic_write(path, data):
check(not path.is_symlink(), "Refusing to overwrite a symlink: " + str(path))
fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=".homegate-")
try:
with os.fdopen(fd, "wb") as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
os.chmod(temporary, 0o600)
os.replace(temporary, path)
finally:
if os.path.exists(temporary):
os.unlink(temporary)
def include_update(original, include_path="config.d/homegate.conf"):
text = original.decode("utf-8")
expected = BEGIN + '\nHost *\n Include "' + include_path + '"\n' + END
check((BEGIN in text) == (END in text), "Incomplete Homegate Include block; repair it manually")
if BEGIN in text:
check(text.count(BEGIN) == 1 and text.count(END) == 1, "Duplicate Homegate Include block")
check(expected in text.replace("\r\n", "\n"), "Homegate Include block was edited; inspect it manually")
return original
suffix = ("\n" if original and not original.endswith(b"\n") else "")
suffix += "\n" + expected + "\n"
return original + suffix.encode()
def install_config(text, ssh_dir, add_include=False):
# Validate before creating directories or changing any existing files.
text = validate_download(text.encode())
check(not ssh_dir.is_symlink(), "SSH directory is a symlink; use its real path with --ssh-dir")
target_dir = ssh_dir / "config.d"
target = target_dir / "homegate.conf"
main = ssh_dir / "config"
check(not target_dir.is_symlink() and not target.is_symlink(), "Generated config path must not be a symlink")
original, updated = b"", b""
if add_include:
check(not main.is_symlink(), "Main config is a symlink; add Include manually")
original = main.read_bytes() if main.exists() else b""
include_path = target.resolve().as_posix()
check(not any(c in include_path for c in '\r\n\x00"$%*?[]'), "SSH directory contains unsupported Include path characters")
updated = include_update(original, include_path)
ssh_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
target_dir.mkdir(exist_ok=True, mode=0o700)
os.chmod(ssh_dir, 0o700)
os.chmod(target_dir, 0o700)
if not target.exists() or target.read_bytes() != text.encode():
atomic_write(target, text.encode())
else:
os.chmod(target, 0o600)
if add_include and updated != original:
if main.exists():
atomic_write(ssh_dir / ("config.before-homegate-" + str(time.time_ns())), original)
atomic_write(main, updated)
return target
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("url", help="e.g. http://192.168.0.10:8099/ssh-config")
parser.add_argument("--install", action="store_true", help="Also append one Include block; back up existing config")
parser.add_argument("--ssh-dir", type=Path, default=Path.home() / ".ssh")
parser.add_argument("--ca-file", help="Trusted PEM CA file for HTTPS")
args = parser.parse_args()
text = download(args.url, args.ca_file)
target = install_config(text, args.ssh_dir.expanduser(), args.install)
print("Updated:", target)
if args.install:
print("Include installed. Existing settings take precedence; check an alias with: ssh -G ALIAS")
else:
print("To add the Include on first use, run again with --install.")
if __name__ == "__main__":
try:
main()
except Exception as exc:
print("Homegate SSH sync failed:", exc, file=sys.stderr)
sys.exit(1)