Add support for ecdsaSecp256k1 and ecdsaSec

This commit is contained in:
Gaël Goinvic committed 2026-03-10 17:54:06 +01:00
1 parent 9d5ce10c3c
commit dfad8e92f1
4 files changed
+154 -9

No files matched your search

+16 -2
View File
@@ -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:
+48
View File
@@ -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(),
)
+81 -3
View File
@@ -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"
+9 -4
View File
@@ -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"