141 lines
7.1 KiB
Python
141 lines
7.1 KiB
Python
"""Initialize a NEW deployment only. Run as root inside the application image."""
|
|
import argparse
|
|
import ipaddress
|
|
import os
|
|
import re
|
|
import secrets
|
|
import ssl
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
from urllib.parse import urlsplit
|
|
|
|
from cryptography import x509
|
|
from cryptography.hazmat.primitives import serialization
|
|
from cryptography.hazmat.primitives.asymmetric import ed25519
|
|
from cryptography.x509.oid import NameOID
|
|
from dotenv import dotenv_values, set_key
|
|
from relay.crypto import issue_ca, pem_private
|
|
|
|
|
|
def initialize(root, test_cert=False):
|
|
root = Path(root)
|
|
if os.name != 'nt' and os.geteuid() != 0:
|
|
raise ValueError('Run initialization as root for container UID 10001 ownership')
|
|
if (root / '.env').exists() or (root / 'runtime/connector/connector.key').exists():
|
|
raise ValueError('Existing deployment detected; initialization will not overwrite it')
|
|
settings = {k: v for k, v in dotenv_values(root / 'settings.env').items() if v is not None}
|
|
required = ['HN_PUBLIC_URL', 'HN_FEISHU_API_BASE', 'HN_FEISHU_AUTHORIZE_URL']
|
|
for field in required:
|
|
value = settings.get(field, '')
|
|
parsed = urlsplit(value)
|
|
if parsed.scheme != 'https' or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment:
|
|
raise ValueError(f'{field} must be a valid HTTPS URL')
|
|
if parsed.hostname.endswith('.invalid'):
|
|
raise ValueError(f'Configure {field} before initializing')
|
|
public = urlsplit(settings['HN_PUBLIC_URL'])
|
|
if public.path not in ('', '/'):
|
|
raise ValueError('HN_PUBLIC_URL must have no path prefix')
|
|
if (public.port or 443) != int(settings.get('HN_HTTPS_PORT', '443')):
|
|
raise ValueError('Public URL port must match HN_HTTPS_PORT')
|
|
if settings.get('HN_FEISHU_ENABLED', 'true').lower() == 'true':
|
|
if not all(settings.get(k) for k in ['HN_FEISHU_APP_ID', 'HN_FEISHU_APP_SECRET']):
|
|
raise ValueError('Configure platform app ID and secret')
|
|
if not re.fullmatch(r'[a-z0-9][a-z0-9_-]*', settings.get('COMPOSE_PROJECT_NAME', 'hainuo-relay')):
|
|
raise ValueError('Invalid Compose project name')
|
|
tls = root / 'runtime/tls'
|
|
tls.mkdir(parents=True, exist_ok=True)
|
|
cert_path, key_path = tls / 'server.pem', tls / 'server.key'
|
|
if test_cert:
|
|
if cert_path.exists() or key_path.exists():
|
|
raise ValueError('Refusing to replace an existing TLS certificate')
|
|
key = ed25519.Ed25519PrivateKey.generate()
|
|
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, public.hostname)])
|
|
try:
|
|
san = x509.IPAddress(ipaddress.ip_address(public.hostname))
|
|
except ValueError:
|
|
san = x509.DNSName(public.hostname)
|
|
now = datetime.now(timezone.utc)
|
|
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key())
|
|
.serial_number(x509.random_serial_number()).not_valid_before(now-timedelta(minutes=5))
|
|
.not_valid_after(now+timedelta(days=30))
|
|
.add_extension(x509.SubjectAlternativeName([san]), critical=False).sign(key, None))
|
|
key_path.write_bytes(pem_private(key))
|
|
cert_path.write_bytes(cert.public_bytes(serialization.Encoding.PEM))
|
|
validate_tls(cert_path, key_path, public.hostname)
|
|
ca_key, ca = issue_ca()
|
|
signer = ed25519.Ed25519PrivateKey.generate()
|
|
for folder in ['runtime/trust', 'runtime/connector', 'runtime/issuer']:
|
|
(root / folder).mkdir(parents=True, exist_ok=False)
|
|
(root / 'runtime/trust/ca.pem').write_bytes(ca.public_bytes(serialization.Encoding.PEM))
|
|
(root / 'runtime/trust/connector.pub').write_bytes(signer.public_key().public_bytes(
|
|
serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo))
|
|
(root / 'runtime/connector/connector.key').write_bytes(pem_private(signer))
|
|
(root / 'runtime/issuer/ca.key').write_bytes(pem_private(ca_key))
|
|
redis_pass, db_pass = secrets.token_hex(32), secrets.token_hex(32)
|
|
url = settings['HN_PUBLIC_URL'].rstrip('/')
|
|
settings.update(HN_ENVIRONMENT='production', HN_PUBLIC_URL=url,
|
|
HN_ROUTER_URL='wss://' + urlsplit(url).netloc + '/device/ws',
|
|
HN_ADMIN_SECRET=secrets.token_hex(32), HN_INTERNAL_SECRET=secrets.token_hex(32),
|
|
HN_REDIS_PASSWORD=redis_pass, HN_POSTGRES_PASSWORD=db_pass,
|
|
HN_REDIS_URL=f'redis://:{redis_pass}@redis:6379/0',
|
|
HN_DATABASE_URL=f'postgresql://hainuo:{db_pass}@postgres:5432/hainuo',
|
|
HN_FEISHU_ENCRYPT_KEY='', HN_FEISHU_VERIFICATION_TOKEN='',
|
|
HN_PROXY_ENABLED='false', HN_DEVICE_DOMAIN='')
|
|
tmp = root / '.env.initializing'
|
|
tmp.touch(mode=0o600, exist_ok=False)
|
|
for key, value in settings.items():
|
|
if '\n' in value or '\r' in value:
|
|
raise ValueError('Multiline settings are unsupported')
|
|
set_key(tmp, key, value, quote_mode='always')
|
|
tmp.replace(root / '.env')
|
|
for folder in ['runtime/connector', 'runtime/issuer']:
|
|
path = root / folder
|
|
path.chmod(0o700)
|
|
if os.name != 'nt':
|
|
os.chown(path, 10001, 10001)
|
|
for file in path.iterdir():
|
|
file.chmod(0o600)
|
|
if os.name != 'nt':
|
|
os.chown(file, 10001, 10001)
|
|
(root / '.env').chmod(0o600)
|
|
(root / 'settings.env').chmod(0o600)
|
|
tls.chmod(0o700)
|
|
key_path.chmod(0o600)
|
|
cert_path.chmod(0o644)
|
|
(root / 'runtime/trust').chmod(0o755)
|
|
for path in (root / 'runtime/trust').iterdir():
|
|
path.chmod(0o644)
|
|
print('Initialized new deployment. No credentials printed. Preserve runtime/issuer/ca.key securely.')
|
|
|
|
|
|
def validate_tls(cert_path, key_path, hostname):
|
|
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
|
context.load_cert_chain(str(cert_path), str(key_path))
|
|
cert = x509.load_pem_x509_certificate(cert_path.read_bytes())
|
|
now = datetime.now(timezone.utc)
|
|
if not cert.not_valid_before_utc <= now <= cert.not_valid_after_utc:
|
|
raise ValueError('Gateway TLS certificate is not currently valid')
|
|
san = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
|
|
try:
|
|
address = ipaddress.ip_address(hostname)
|
|
except ValueError:
|
|
host = hostname.encode('idna').decode().lower()
|
|
def matches(name):
|
|
name = name.lower()
|
|
return name == host or (name.startswith('*.') and name.count('*') == 1
|
|
and len(host.split('.')) == len(name.split('.'))
|
|
and host.split('.', 1)[1] == name[2:])
|
|
valid = any(matches(x) for x in san.get_values_for_type(x509.DNSName))
|
|
else:
|
|
valid = address in san.get_values_for_type(x509.IPAddress)
|
|
if not valid:
|
|
raise ValueError('Gateway TLS certificate hostname mismatch')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('--root', default='/work')
|
|
parser.add_argument('--test-cert', action='store_true')
|
|
args = parser.parse_args()
|
|
initialize(args.root, args.test_cert)
|