Merge pull request #48 from Guiliano99/FixAddCompositeNames

Fix Addtional Composite Version Name Inconsistencies

Author: ralienpp

Makefile

@@ -113,7 +113,7 @@ test-pq-hybrid:
 
 test-pq-hybrid-verbose:
     # Start the tests for PQ and Hybrid algorithms/mechanisms.
-	robot --pythonpath=./ --outputdir=reports --variable environment:$(env) tests_pq_and_hybrid
+	robot --pythonpath=./ --exclude "composite-kemANDfrodokem" --outputdir=reports --variable environment:$(env) tests_pq_and_hybrid
 
 start-mock-ca:
 	python ./mock_ca/ca_handler.py
@@ -128,4 +128,3 @@ test-mock-ca-verbose:
 	# The results will be stored in the reports/ directory.
 	# This will run all tests, including those marked as verbose-tests.
 	robot --pythonpath=./ --outputdir=reports --variable environment:mock_ca tests tests_mock_ca tests_pq_and_hybrid
-

…vectors/composite_kem07_testvectors.json …t_vectors/composite_kem_testvectors.jsondata/rfc_test_vectors/composite_kem07_testvectors.json renamed to data/rfc_test_vectors/composite_kem_testvectors.json data/rfc_test_vectors/composite_kem07_testvectors.json renamed to data/rfc_test_vectors/composite_kem_testvectors.json

@@ -57,8 +57,8 @@
 from pq_logic.keys.xwing import XWingPrivateKey, XWingPublicKey
 from pq_logic.tmp_oids import (
     CHEMPAT_OID_2_NAME,
-    COMPOSITE_KEM07_NAME_2_OID,
-    COMPOSITE_KEM07_OID_2_NAME,
+    COMPOSITE_KEM_NAME_2_OID,
+    COMPOSITE_KEM_OID_2_NAME,
     COMPOSITE_SIG_OID_TO_NAME,
     id_rsa_kem_spki,
 )
@@ -94,7 +94,11 @@ def _any_string_in_string(string: str, options: List[str]) -> str:
 class CombinedKeyFactory:
     """Factory for creating all known key types."""
 
-    _composite_prefixes = ["sig-13", "kem-07", "kem07", "dhkem", "kem", "sig"]
+    _composite_prefixes = [
+        "dhkem",
+        "kem",
+        "sig",
+    ]
 
     @staticmethod
     def get_stateful_sig_algorithms() -> Dict[str, List[str]]:
@@ -278,16 +282,16 @@ def _get_pq_and_trad_names(
         return pq_name, trad_name, curve, length
 
     @staticmethod
-    def _load_composite_kem07_public_key(oid: univ.ObjectIdentifier, public_key: bytes):
-        """Load a composite KEM 06 public key from the provided OID and public key bytes.
+    def _load_composite_kem_public_key(oid: univ.ObjectIdentifier, public_key: bytes):
+        """Load a composite KEM public key from the provided OID and public key bytes.
 
         :param oid: The OID of the key.
         :param public_key: The public key bytes.
         :return: The loaded public key.
         :raises BadAsn1Data: If the public key structure is invalid or cannot be decoded.
         :raises InvalidKeyCombination: If the key is invalid or the combination is not supported.
         """
-        orig_name = COMPOSITE_KEM07_OID_2_NAME[oid]
+        orig_name = COMPOSITE_KEM_OID_2_NAME[oid]
 
         pq_name, trad_name = CombinedKeyFactory.get_pq_and_trad_name_form_hybrid_name(orig_name)
         pq_key, rest = PQKeyFactory.from_public_bytes(pq_name, public_key, allow_rest=True)
@@ -338,8 +342,8 @@ def _load_hybrid_key_from_spki(spki: rfc5280.SubjectPublicKeyInfo):
                 public_key_bytes=spki["subjectPublicKey"].asOctets(),
             )
 
-        if oid in COMPOSITE_KEM07_OID_2_NAME:
-            return CombinedKeyFactory._load_composite_kem07_public_key(oid, spki["subjectPublicKey"].asOctets())
+        if oid in COMPOSITE_KEM_OID_2_NAME:
+            return CombinedKeyFactory._load_composite_kem_public_key(oid, spki["subjectPublicKey"].asOctets())
 
         if oid in CHEMPAT_OID_2_NAME or oid in CHEMPAT_OID_2_NAME:
             return CombinedKeyFactory.load_chempat_key(spki)
@@ -363,7 +367,7 @@ def load_public_key_from_spki(spki: Union[rfc5280.SubjectPublicKeyInfo, bytes]):
         if str(oid) == XWING_OID_STR:
             return XWingPublicKey.from_public_bytes(spki["subjectPublicKey"].asOctets())
 
-        if oid in COMPOSITE_SIG_OID_TO_NAME or oid in COMPOSITE_KEM07_OID_2_NAME or oid in CHEMPAT_OID_2_NAME:
+        if oid in COMPOSITE_SIG_OID_TO_NAME or oid in COMPOSITE_KEM_OID_2_NAME or oid in CHEMPAT_OID_2_NAME:
             return CombinedKeyFactory._load_hybrid_key_from_spki(spki)
 
         if oid in PQ_STATEFUL_HASH_SIG_OID_2_NAME:
@@ -444,14 +448,14 @@ def _load_trad_private_key_from_data(name, trad_data, curve: Optional[str] = Non
         return trad_key
 
     @staticmethod
-    def _load_composite_kem07_from_private_bytes(algorithm: str, private_key: bytes) -> CompositeKEMPrivateKey:
-        """Load a Composite KEM v7 public key from private key bytes.
+    def _load_composite_kem_from_private_bytes(algorithm: str, private_key: bytes) -> CompositeKEMPrivateKey:
+        """Load a Composite KEM public key from private key bytes.
 
         :param algorithm: The name of the algorithm.
         :param private_key: The private key bytes.
         :return: A CompositeKEMPublicKey instance.
         """
-        logging.info("Loading composite KEM-07 private key: %s", algorithm)
+        logging.info("Loading composite KEM private key: %s", algorithm)
 
         pq_name, trad_name = CombinedKeyFactory.get_pq_and_trad_name_form_hybrid_name(algorithm)
         tmp_pq_key = PQKeyFactory.generate_pq_key(pq_name)
@@ -468,7 +472,7 @@ def _load_composite_kem07_from_private_bytes(algorithm: str, private_key: bytes)
         trad_key = CombinedKeyFactory._load_trad_composite_private_key(
             trad_name=trad_name,
             trad_key_bytes=trad_bytes,
-            prefix="KEM v7" if "dhkem" not in algorithm.lower() else "dhkem v7",
+            prefix="KEM" if "dhkem" not in algorithm.lower() else "DHKEM",
         )
 
         if not isinstance(trad_key, rsa.RSAPrivateKey):
@@ -496,20 +500,20 @@ def _load_composite_kem07_from_private_bytes(algorithm: str, private_key: bytes)
         return composite_key
 
     @staticmethod
-    def _decode_composite_kem07(
+    def _decode_composite_kem(
         name: str,
         private_key_bytes: bytes,
         public_key: Optional[bytes],
     ) -> CompositeKEMPrivateKey:
-        """Decode a composite KEM-07 private key."""
-        private_key = CombinedKeyFactory._load_composite_kem07_from_private_bytes(
+        """Decode a composite KEM private key."""
+        private_key = CombinedKeyFactory._load_composite_kem_from_private_bytes(
             algorithm=name,
             private_key=private_key_bytes,
         )
 
         if public_key is not None:
             spki = rfc5280.SubjectPublicKeyInfo()
-            spki["algorithm"]["algorithm"] = COMPOSITE_KEM07_NAME_2_OID[name]
+            spki["algorithm"]["algorithm"] = COMPOSITE_KEM_NAME_2_OID[name]
             spki["subjectPublicKey"] = univ.BitString.fromOctetString(public_key)
             try:
                 pub_key = CombinedKeyFactory.load_public_key_from_spki(spki)
@@ -575,9 +579,9 @@ def load_private_key_from_one_asym_key(
             name = COMPOSITE_SIG_OID_TO_NAME[oid]
             return CombinedKeyFactory._load_composite_sig_key(name, private_bytes, public_bytes)
 
-        if oid in COMPOSITE_KEM07_OID_2_NAME:
-            _name = COMPOSITE_KEM07_OID_2_NAME[oid]
-            return CombinedKeyFactory._decode_composite_kem07(_name, private_bytes, public_bytes)
+        if oid in COMPOSITE_KEM_OID_2_NAME:
+            _name = COMPOSITE_KEM_OID_2_NAME[oid]
+            return CombinedKeyFactory._decode_composite_kem(_name, private_bytes, public_bytes)
 
         if oid == id_rsa_kem_spki:
             return RSADecapKey.from_pkcs8(one_asym_key)
@@ -826,14 +830,8 @@ def get_pq_and_trad_name_form_hybrid_name(hybrid_name: str) -> Tuple[str, str]:
         # Determine the prefix based on the algorithm name
         if alg.startswith("chempat-"):
             prefix = "chempat-"
-        elif alg.startswith("composite-sig-13-"):
-            prefix = "composite-sig-13-"
         elif alg.startswith("composite-sig-"):
             prefix = "composite-sig-"
-        elif alg.startswith("composite-kem-07-"):
-            prefix = "composite-kem-07-"
-        elif alg.startswith("composite-kem07-"):
-            prefix = "composite-kem07-"
         elif alg.startswith("composite-dhkem-"):
             prefix = "composite-dhkem-"
         elif alg.startswith("composite-kem-"):
@@ -877,7 +875,7 @@ def _load_composite_sig_from_private_bytes(algorithm: str, private_key: bytes) -
         pq_key = MLDSAPrivateKey.from_private_bytes(pq_bytes, name=pq_name)
 
         trad_key = CombinedKeyFactory._load_trad_composite_private_key(
-            trad_name=trad_name, trad_key_bytes=trad_bytes, prefix="Sig v13"
+            trad_name=trad_name, trad_key_bytes=trad_bytes, prefix="Sig"
         )
 
         use_pss = trad_name.endswith("-pss")
@@ -943,15 +941,15 @@ def _load_trad_raw_key(
 
     @staticmethod
     def _load_trad_composite_private_key(
-        trad_name: str, trad_key_bytes: bytes, prefix: str = "Sig v13"
+        trad_name: str, trad_key_bytes: bytes, prefix: str = "Sig"
     ) -> Union[
         RSAPrivateKey, Ed25519PrivateKey, Ed448PrivateKey, X25519PrivateKey, X448PrivateKey, ec.EllipticCurvePrivateKey
     ]:
         """Load a composite signature key from the given bytes.
 
         :param trad_name: The name of the algorithm, e.g., "rsa2048-pss".
         :param trad_key_bytes: The traditional key bytes for RSA, ECDH, ECDSA, or EdDSA keys.
-        :param prefix: The prefix for the algorithm, e.g., "Sig v13".
+        :param prefix: The prefix for the algorithm, e.g., "Sig".
         """
         try:
             if trad_name.startswith("ecdsa") or trad_name.startswith("ecdh"):

…vectors/composite_sig13_testvectors.json …t_vectors/composite_sig_testvectors.jsondata/rfc_test_vectors/composite_sig13_testvectors.json renamed to data/rfc_test_vectors/composite_sig_testvectors.json data/rfc_test_vectors/composite_sig13_testvectors.json renamed to data/rfc_test_vectors/composite_sig_testvectors.json

@@ -38,7 +38,7 @@
 from pq_logic.keys.composite_sig import CompositeSigPrivateKey, CompositeSigPublicKey
 from pq_logic.keys.sig_keys import MLDSAPrivateKey
 from pq_logic.tmp_oids import (
-    COMPOSITE_SIG13_OID_TO_NAME,
+    COMPOSITE_SIG_OID_TO_NAME,
     id_altSignatureExt,
     id_ce_deltaCertificateDescriptor,
     id_relatedCert,
@@ -331,7 +331,7 @@ def build_cert_from_catalyst_request(  # noqa: D417 Missing argument description
 
     popo: rfc4211.ProofOfPossession = cert_req_msg["popo"]
 
-    if cert_req_msg["certReq"]["certTemplate"]["publicKey"]["algorithm"]["algorithm"] in COMPOSITE_SIG13_OID_TO_NAME:
+    if cert_req_msg["certReq"]["certTemplate"]["publicKey"]["algorithm"]["algorithm"] in COMPOSITE_SIG_OID_TO_NAME:
         raise ValueError("Composite keys are not supported for Catalyst certificates.")
 
     cert_template = cert_req_msg["certReq"]["certTemplate"]
@@ -546,7 +546,7 @@ def verify_sig_popo_catalyst_cert_req_msg(  # noqa: D417 Missing argument descri
     sig_alg_oid = cert_req_msg["popo"]["signature"]["algorithmIdentifier"]
     oid = sig_alg_oid["algorithm"]
 
-    if oid in COMPOSITE_SIG13_OID_TO_NAME:
+    if oid in COMPOSITE_SIG_OID_TO_NAME:
         if not isinstance(first_key, PQSignaturePublicKey):
             first_key, alt_pub_key = alt_pub_key, first_key
 
@@ -1276,8 +1276,8 @@ def is_hybrid_cert(cert: rfc9480.CMPCertificate) -> Optional[str]:
     """
     alg_oid = cert["tbsCertificate"]["subjectPublicKeyInfo"]["algorithm"]["algorithm"]
 
-    if alg_oid in COMPOSITE_SIG13_OID_TO_NAME:
-        return "composite-sig-13"
+    if alg_oid in COMPOSITE_SIG_OID_TO_NAME:
+        return "composite-sig"
 
     dcd = certextractutils.get_extension(cert["tbsCertificate"]["extensions"], id_ce_deltaCertificateDescriptor)
     if dcd is not None:

pq_logic/combined_factory.py

@@ -29,7 +29,7 @@
     TradKEMPublicKey,
 )
 from pq_logic.keys.trad_kem_keys import DHKEMPrivateKey, DHKEMPublicKey, RSADecapKey, RSAEncapKey
-from pq_logic.tmp_oids import COMPOSITE_KEM07_NAME_2_OID
+from pq_logic.tmp_oids import COMPOSITE_KEM_NAME_2_OID
 from resources.exceptions import InvalidKeyCombination
 from resources.typingutils import ECDHPrivateKey, ECDHPublicKey
 
@@ -47,11 +47,11 @@ def _get_kdf_algorithm(pq_name: str, trad_key: TradKEMPublicKey) -> str:
 
 
 class CompositeKEMPublicKey(HybridKEMPublicKey, AbstractCompositePublicKey):
-    """A Composite KEM public key for the Composite KEM 07."""
+    """A Composite KEM public key for the current draft."""
 
     _trad_key: TradKEMPublicKey
     _pq_key: PQKEMPublicKey
-    _name = "composite-kem07"
+    _name = "composite-kem"
 
     def __init__(self, pq_key: PQKEMPublicKey, trad_key: Union[TradKEMPublicKey, ECDHPublicKey, RSAPublicKey]):
         """Initialize the composite KEM public key."""
@@ -88,9 +88,9 @@ def name(self) -> str:
 
     def get_oid(self) -> univ.ObjectIdentifier:
         """Return the OID of the composite KEM."""
-        if COMPOSITE_KEM07_NAME_2_OID.get(self.name) is None:
+        if COMPOSITE_KEM_NAME_2_OID.get(self.name) is None:
             raise InvalidKeyCombination(f"Unsupported composite KEM combination: {self.name}")
-        return COMPOSITE_KEM07_NAME_2_OID[self.name]
+        return COMPOSITE_KEM_NAME_2_OID[self.name]
 
     def kem_combiner(
         self, mlkem_ss: bytes, trad_ss: bytes, trad_ct: bytes, trad_pk: bytes, use_in_cms: bool = False
@@ -185,11 +185,11 @@ def public_bytes_raw(self) -> bytes:
 
 
 class CompositeKEMPrivateKey(HybridKEMPrivateKey, AbstractCompositePrivateKey):
-    """A Composite KEM private key for the Composite KEM 07."""
+    """A Composite KEM private key for the current draft."""
 
     _trad_key: TradKEMPrivateKey
     _pq_key: PQKEMPrivateKey
-    _name = "composite-kem07"
+    _name = "composite-kem"
 
     def __init__(self, pq_key: PQKEMPrivateKey, trad_key: Union[TradKEMPrivateKey, ECDHPrivateKey, RSAPrivateKey]):
         """Initialize the composite KEM private key."""
@@ -250,9 +250,9 @@ def get_oid(self) -> univ.ObjectIdentifier:
             name = f"{self._name}-{self.pq_key.name}-rsa{value}"
         else:
             name = self.name
-        if COMPOSITE_KEM07_NAME_2_OID.get(name) is None:
+        if COMPOSITE_KEM_NAME_2_OID.get(name) is None:
             raise InvalidKeyCombination(f"Unsupported composite KEM combination: {name}")
-        return COMPOSITE_KEM07_NAME_2_OID[name]
+        return COMPOSITE_KEM_NAME_2_OID[name]
 
     def public_key(self) -> CompositeKEMPublicKey:
         """Return the public key associated with this private key."""