From dfad8e92f1d1bbdc052d7f9fa7be275e9257e6fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ga=C3=ABl=20Goinvic?= Date: Tue, 10 Mar 2026 17:21:21 +0100 Subject: [PATCH] Add support for ecdsaSecp256k1 and ecdsaSec --- scripts/migration/mas.py | 18 ++++- scripts/migration/tests/conftest.py | 48 ++++++++++++ scripts/migration/tests/test_mas_secrets.py | 84 ++++++++++++++++++++- scripts/migration/utils.py | 13 +++- 4 files changed, 154 insertions(+), 9 deletions(-) diff --git a/scripts/migration/mas.py b/scripts/migration/mas.py index c27844e3..8e502ed5 100644 --- a/scripts/migration/mas.py +++ b/scripts/migration/mas.py @@ -186,6 +186,20 @@ class MASSecretDiscovery(SecretDiscoveryStrategy): 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]: @@ -238,7 +252,7 @@ class MASSecretDiscovery(SecretDiscoveryStrategy): with open(filepath, "rb") as f: content = f.read() key_type = detect_key_type(content) - if key_type in ["rsa", "ecdsaPrime256v1"]: + 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: @@ -292,7 +306,7 @@ class MASSecretDiscovery(SecretDiscoveryStrategy): if content and config_key: key_type = detect_key_type(content) - if key_type in ["rsa", "ecdsaPrime256v1"]: + 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: diff --git a/scripts/migration/tests/conftest.py b/scripts/migration/tests/conftest.py index c80007cf..3ef26570 100644 --- a/scripts/migration/tests/conftest.py +++ b/scripts/migration/tests/conftest.py @@ -10,6 +10,9 @@ Centralizes common test configurations to reduce duplication. import pytest import yaml +from cryptography.hazmat.backends import default_backend +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric import ec, rsa @pytest.fixture @@ -213,3 +216,48 @@ def ecdsa_key_der(): format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.NoEncryption(), ) + + +@pytest.fixture +def ecdsa_secp256k1_key_pem(): + """Generate a sample ECDSA Secp256k1 private key in PEM format using PKCS1.""" + key = ec.generate_private_key(ec.SECP256K1(), backend=default_backend()) + return key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) + + +@pytest.fixture +def ecdsa_secp256k1_key_der(): + """Generate a sample ECDSA Secp256k1 private key in DER format using PKCS1.""" + key = ec.generate_private_key(ec.SECP256K1(), backend=default_backend()) + return key.private_bytes( + encoding=serialization.Encoding.DER, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) + + +@pytest.fixture +def ecdsa_secp384r1_key_pem(): + """Generate a sample ECDSA Secp384r1 private key in PEM format using PKCS1.""" + + key = ec.generate_private_key(ec.SECP384R1(), backend=default_backend()) + return key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) + + +@pytest.fixture +def ecdsa_secp384r1_key_der(): + """Generate a sample ECDSA Secp384r1 private key in DER format using PKCS1.""" + key = ec.generate_private_key(ec.SECP384R1(), backend=default_backend()) + return key.private_bytes( + encoding=serialization.Encoding.DER, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) diff --git a/scripts/migration/tests/test_mas_secrets.py b/scripts/migration/tests/test_mas_secrets.py index 16d582c2..183d6aff 100644 --- a/scripts/migration/tests/test_mas_secrets.py +++ b/scripts/migration/tests/test_mas_secrets.py @@ -25,22 +25,43 @@ def test_discover_secrets_from_mas_config(basic_mas_config): assert discovery.discovered_secrets["matrixAuthenticationService.encryptionSecret"].value == "my_encryption_key" -def test_key_detection_utility(rsa_key_pem, rsa_key_der, ecdsa_key_pem, ecdsa_key_der): +def test_key_detection_utility( + rsa_key_pem, + rsa_key_der, + ecdsa_key_pem, + ecdsa_key_der, + ecdsa_secp256k1_key_pem, + ecdsa_secp256k1_key_der, + ecdsa_secp384r1_key_pem, + ecdsa_secp384r1_key_der, +): """Test the key type detection utility function.""" from ..utils import detect_key_type # Test RSA PEM assert detect_key_type(rsa_key_pem) == "rsa" - # Test ECDSA PEM + # Test ECDSA Prime256v1 PEM assert detect_key_type(ecdsa_key_pem) == "ecdsaPrime256v1" # Test RSA DER assert detect_key_type(rsa_key_der) == "rsa" - # Test ECDSA DER + # Test ECDSA Prime256v1 DER assert detect_key_type(ecdsa_key_der) == "ecdsaPrime256v1" + # Test ECDSA Secp256k1 PEM + assert detect_key_type(ecdsa_secp256k1_key_pem) == "ecdsaSecp256k1" + + # Test ECDSA Secp256k1 DER + assert detect_key_type(ecdsa_secp256k1_key_der) == "ecdsaSecp256k1" + + # Test ECDSA Secp384r1 PEM + assert detect_key_type(ecdsa_secp384r1_key_pem) == "ecdsaSecp384r1" + + # Test ECDSA Secp384r1 DER + assert detect_key_type(ecdsa_secp384r1_key_der) == "ecdsaSecp384r1" + # Test invalid content assert detect_key_type(b"invalid content") == "unknown" assert detect_key_type(b"") == "unknown" @@ -185,7 +206,64 @@ def test_no_keys_config(basic_mas_config): # Key secrets should be marked for initialization since they're not required assert "matrixAuthenticationService.keys.rsa" in discovery.init_by_ess_secrets assert "matrixAuthenticationService.keys.ecdsaPrime256v1" in discovery.init_by_ess_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp256k1" in discovery.init_by_ess_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp384r1" in discovery.init_by_ess_secrets # Should not be in discovered secrets assert "matrixAuthenticationService.keys.rsa" not in discovery.discovered_secrets assert "matrixAuthenticationService.keys.ecdsaPrime256v1" not in discovery.discovered_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp256k1" not in discovery.discovered_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp384r1" not in discovery.discovered_secrets + + +def test_all_key_types_discovery( + tmp_path, rsa_key_pem, ecdsa_key_pem, ecdsa_secp256k1_key_pem, ecdsa_secp384r1_key_pem +): + """Test discovery of all supported key types from keys_dir.""" + # Create keys directory + keys_dir = tmp_path / "keys" + keys_dir.mkdir() + + # Write all key types + (keys_dir / "rsa_key.pem").write_bytes(rsa_key_pem) + (keys_dir / "ecdsa_prime256v1_key.pem").write_bytes(ecdsa_key_pem) + (keys_dir / "ecdsa_secp256k1_key.pem").write_bytes(ecdsa_secp256k1_key_pem) + (keys_dir / "ecdsa_secp384r1_key.pem").write_bytes(ecdsa_secp384r1_key_pem) + + # Create MAS config with keys_dir + mas_config = { + "http": {"public_base": "https://auth.example.com"}, + "database": {"uri": "postgresql://mas:mas_password@postgres:5432/mas"}, + "secrets": {"encryption": "my_encryption_key", "keys_dir": str(keys_dir)}, + "matrix": { + "homeserver": "test.example.com", + "secret": "synapse_shared_secret_abcdef", + }, + } + + # Test discovery + mas_secrets = MASSecretDiscovery() + discovery = SecretDiscovery(mas_secrets, logging.getLogger(), "mas.yaml") + discovery.discover_secrets(mas_config) + + # Verify all key types were discovered + assert "matrixAuthenticationService.keys.rsa" in discovery.discovered_secrets + assert "matrixAuthenticationService.keys.ecdsaPrime256v1" in discovery.discovered_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp256k1" in discovery.discovered_secrets + assert "matrixAuthenticationService.keys.ecdsaSecp384r1" in discovery.discovered_secrets + + # Verify key values + rsa_secret = discovery.discovered_secrets["matrixAuthenticationService.keys.rsa"] + ecdsa_prime256v1_secret = discovery.discovered_secrets["matrixAuthenticationService.keys.ecdsaPrime256v1"] + ecdsa_secp256k1_secret = discovery.discovered_secrets["matrixAuthenticationService.keys.ecdsaSecp256k1"] + ecdsa_secp384r1_secret = discovery.discovered_secrets["matrixAuthenticationService.keys.ecdsaSecp384r1"] + + assert rsa_secret.value == rsa_key_pem.decode("utf-8") + assert ecdsa_prime256v1_secret.value == ecdsa_key_pem.decode("utf-8") + assert ecdsa_secp256k1_secret.value == ecdsa_secp256k1_key_pem.decode("utf-8") + assert ecdsa_secp384r1_secret.value == ecdsa_secp384r1_key_pem.decode("utf-8") + + # Verify config keys + for secret_key in discovery.discovered_secrets: + if secret_key.startswith("matrixAuthenticationService.keys."): + assert discovery.discovered_secrets[secret_key].config_key == "secrets.keys_dir" diff --git a/scripts/migration/utils.py b/scripts/migration/utils.py index 8f215a8f..05edb8f9 100644 --- a/scripts/migration/utils.py +++ b/scripts/migration/utils.py @@ -194,7 +194,7 @@ def detect_key_type(content: bytes) -> str: content: Binary content of the key file Returns: - String indicating key type: "rsa", "ecdsaPrime256v1", or "unknown" + String indicating key type: "rsa", "ecdsaPrime256v1", "ecdsaSecp256k1", "ecdsaSecp384r1", or "unknown" """ try: # Try to load as PEM first (check for PEM headers) @@ -207,9 +207,14 @@ def detect_key_type(content: bytes) -> str: # Determine key type if isinstance(key, rsa.RSAPrivateKey): return "rsa" - elif isinstance(key, ec.EllipticCurvePrivateKey) and key.curve.name == "secp256r1": - # Check if it's NIST P-256 (secp256r1) curve - return "ecdsaPrime256v1" + elif isinstance(key, ec.EllipticCurvePrivateKey): + # Check curve type + if key.curve.name == "secp256r1": + return "ecdsaPrime256v1" + elif key.curve.name == "secp256k1": + return "ecdsaSecp256k1" + elif key.curve.name == "secp384r1": + return "ecdsaSecp384r1" # Unknown key type return "unknown"