# Copyright 2026 Element Creations Ltd # # SPDX-License-Identifier: AGPL-3.0-only """ Synapse-specific migration strategy. """ import logging import os import urllib from dataclasses import dataclass from typing import Any from .interfaces import ExtraFilesDiscoveryStrategy, SecretDiscoveryStrategy from .migration import MigrationStrategy, TransformationSpec from .models import DiscoveredSecret, SecretConfig from .utils import detect_key_type, extract_hostname_from_url logger = logging.getLogger("migration") def parse_postgres_uri(uri: str) -> dict[str, Any]: """ Parse a PostgreSQL connection URI and extract database configuration. Args: uri: PostgreSQL connection URI (e.g., "postgresql://user:pass@host:port/db?sslmode=prefer") Returns: Dictionary with database configuration fields (port is returned as int) """ if not uri or not uri.startswith("postgresql://"): return {} try: # Parse the URI parsed = urllib.parse.urlparse(uri) # Build result dictionary only with fields that are actually present result: dict[str, str | int | None] = {} if parsed.hostname: result["host"] = parsed.hostname if parsed.port: result["port"] = int(parsed.port) if parsed.username: result["user"] = parsed.username if parsed.password: result["password"] = parsed.password if parsed.path: result["name"] = parsed.path.lstrip("/") # Extract SSL mode from query parameters (only if present) if parsed.query: query_params = urllib.parse.parse_qs(parsed.query) if "sslmode" in query_params: result["ssl"] = query_params["sslmode"][0] return result except Exception as e: logging.warning(f"Failed to parse PostgreSQL URI '{uri}': {e}") return {} def extract_port_from_uri(_, uri: str) -> int | None: """ Extract port from PostgreSQL URI, returning None if not present. Args: uri: PostgreSQL connection URI Returns: Port as integer if present, None otherwise """ parsed = parse_postgres_uri(uri) port = parsed.get("port") return int(port) if port is not None else None @dataclass class MASMigration(MigrationStrategy): """MAS-specific migration implementation.""" @property def component_root_key(self) -> str: return "matrixAuthenticationService" @property def override_configs(self) -> set[str]: return { "http", # The entire HTTP configuration is managed by ESS "database.uri", # Database URI configuration is managed by ESS" "secrets.keys", } @property def transformations(self) -> list[TransformationSpec]: return [ TransformationSpec( src_key="database.uri", target_key="matrixAuthenticationService.postgres.host", transformer=lambda _, uri: parse_postgres_uri(uri).get("host"), required=True, ), TransformationSpec( src_key="database.uri", target_key="matrixAuthenticationService.postgres.port", transformer=extract_port_from_uri, required=False, ), TransformationSpec( src_key="database.uri", target_key="matrixAuthenticationService.postgres.user", transformer=lambda _, uri: parse_postgres_uri(uri).get("user"), required=True, ), TransformationSpec( src_key="database.uri", target_key="matrixAuthenticationService.postgres.database", transformer=lambda _, uri: parse_postgres_uri(uri).get("name"), required=True, ), TransformationSpec( src_key="database.uri", target_key="matrixAuthenticationService.postgres.sslMode", transformer=lambda _, uri: parse_postgres_uri(uri).get("ssl"), required=False, ), TransformationSpec( src_key="http.public_base", target_key="matrixAuthenticationService.ingress.host", transformer=extract_hostname_from_url, ), # Extract hostname from http.public_base for ingress host ] class MASSecretDiscovery(SecretDiscoveryStrategy): """MAS-specific secret discovery implementation.""" @property def component_name(self) -> str: return "Matrix Authentication Service" @property def ess_secret_schema(self) -> dict[str, SecretConfig]: """Get the ESS secret schema for MAS.""" return { # MAS secrets "matrixAuthenticationService.postgres.password": SecretConfig( init_if_missing_from_source_cfg=True, # Must be provided description="MAS database password", config_inline="database.uri", config_path=None, transformer=lambda uri: parse_postgres_uri(uri).get("password"), ), "matrixAuthenticationService.synapseSharedSecret": SecretConfig( init_if_missing_from_source_cfg=True, # Can be auto-generated description="MAS Synapse shared secret", config_inline="matrix.secret", config_path="matrix.secret_file", ), "matrixAuthenticationService.encryptionSecret": SecretConfig( init_if_missing_from_source_cfg=True, # Must be provided description="MAS encryption secret", config_inline="secrets.encryption", config_path="secrets.encryption_file", ), # Key secrets - these will be discovered through special key processing "matrixAuthenticationService.keys.rsa": SecretConfig( init_if_missing_from_source_cfg=True, description="MAS RSA private key for signing operations", config_inline=None, config_path=None, transformer=None, ), "matrixAuthenticationService.keys.ecdsaPrime256v1": SecretConfig( init_if_missing_from_source_cfg=True, description="MAS ECDSA Prime256v1 private key for signing operations", config_inline=None, config_path=None, transformer=None, ), "matrixAuthenticationService.keys.ecdsaSecp256k1": SecretConfig( init_if_missing_from_source_cfg=True, description="MAS ECDSA Secp256k1 private key for signing operations", config_inline=None, config_path=None, transformer=None, ), "matrixAuthenticationService.keys.ecdsaSecp384r1": SecretConfig( init_if_missing_from_source_cfg=True, description="MAS ECDSA Secp384r1 private key for signing operations", config_inline=None, config_path=None, transformer=None, ), } def discover_component_specific_secrets(self, config_data: dict) -> dict[str, DiscoveredSecret]: """ Discover component-specific secrets from MAS configuration. Args: config_data: MAS configuration data Returns: Dictionary mapping ESS secret keys to DiscoveredSecret objects """ discovered_secrets: dict[str, DiscoveredSecret] = {} # Handle keys_dir (directory scanning) keys_dir = config_data.get("secrets", {}).get("keys_dir") if keys_dir: dir_secrets = self._process_keys_directory(keys_dir) discovered_secrets.update(dir_secrets) # Handle individual keys keys_config = config_data.get("secrets", {}).get("keys", []) if keys_config: individual_secrets = self._process_individual_keys(keys_config) # Individual keys take precedence over directory keys discovered_secrets.update(individual_secrets) return discovered_secrets def _process_keys_directory(self, keys_dir: str) -> dict[str, DiscoveredSecret]: """ Process all key files in a directory. Args: keys_dir: Path to directory containing key files Returns: Dictionary mapping ESS secret keys to DiscoveredSecret objects """ discovered_secrets: dict[str, DiscoveredSecret] = {} try: if not os.path.isdir(keys_dir): logger.warning(f"Keys directory does not exist: {keys_dir}") return discovered_secrets for filename in os.listdir(keys_dir): filepath = os.path.join(keys_dir, filename) if os.path.isfile(filepath): try: with open(filepath, "rb") as f: content = f.read() key_type = detect_key_type(content) if key_type in ["rsa", "ecdsaPrime256v1", "ecdsaSecp256k1", "ecdsaSecp384r1"]: secret_key = f"matrixAuthenticationService.keys.{key_type}" # Only set if not already discovered (prefer individual keys over directory) if secret_key not in discovered_secrets: discovered_secret = DiscoveredSecret( source_file="mas.yaml", secret_key=secret_key, config_key="secrets.keys_dir", value=content.decode("utf-8") ) discovered_secrets[secret_key] = discovered_secret logger.info(f"Discovered {key_type} key from file: {filepath}") except Exception as e: logger.warning(f"Failed to process key file {filepath}: {e}") except Exception as e: logger.warning(f"Failed to process keys directory {keys_dir}: {e}") return discovered_secrets def _process_individual_keys(self, keys_config: list) -> dict[str, DiscoveredSecret]: """ Process individual key configurations. Args: keys_config: List of key configuration dictionaries Returns: Dictionary mapping ESS secret keys to DiscoveredSecret objects """ discovered_secrets: dict[str, DiscoveredSecret] = {} for index, key_config in enumerate(keys_config): content = None config_key = None # Try key_file first if "key_file" in key_config: try: with open(key_config["key_file"], "rb") as f: content = f.read() config_key = f"secrets.keys.{index}.key_file" logger.info(f"Read key from file: {key_config['key_file']}") except Exception as e: logger.warning(f"Failed to read key file {key_config['key_file']}: {e}") continue # Try inline key content elif "key" in key_config: content = key_config["key"].encode("utf-8") config_key = f"secrets.keys.{index}.key" logger.info("Read key from inline content") if content and config_key: key_type = detect_key_type(content) if key_type in ["rsa", "ecdsaPrime256v1", "ecdsaSecp256k1", "ecdsaSecp384r1"]: secret_key = f"matrixAuthenticationService.keys.{key_type}" # Only set if not already discovered (prefer individual keys over directory) if secret_key not in discovered_secrets: discovered_secret = DiscoveredSecret( source_file="mas.yaml", secret_key=secret_key, config_key=config_key, value=content.decode("utf-8") ) discovered_secrets[secret_key] = discovered_secret logger.info(f"Discovered {key_type} key from individual configuration") return discovered_secrets class MASExtraFileDiscovery(ExtraFilesDiscoveryStrategy): @property def component_name(self) -> str: return "Matrix Authentication Service" @property def ignored_config_keys(self) -> list[str]: # Keep secrets.keys_dir in ignored keys for extra files discovery # as it's processed by specialized key discovery logic return ["secrets.keys_dir"] @property def ignored_file_paths(self) -> list[str]: """Files paths to ignore when discovering extra files.""" ... return []