mplang-nightly 0.1.dev258__tar.gz → 0.1.dev260__tar.gz

{mplang_nightly-0.1.dev258 → mplang_nightly-0.1.dev260}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mplang-nightly
-Version: 0.1.dev258
+Version: 0.1.dev260
 Summary: Multi-Party Programming Language
 Author-email: SecretFlow Team <secretflow-contact@service.alipay.com>
 License:                                  Apache License

{mplang_nightly-0.1.dev258 → mplang_nightly-0.1.dev260}/mplang/v2/backends/tee_impl.py

@@ -155,7 +155,8 @@ def _quote_gen_impl(
             f"got {type(pk).__name__}"
         )
 
-    platform = op.attrs.get("platform", "mock")
+    # In a real implementation, the platform would be detected from the environment
+    platform = "mock"
 
     return MockQuoteValue(
         platform=platform,

{mplang_nightly-0.1.dev258 → mplang_nightly-0.1.dev260}/mplang/v2/dialects/tee.py

@@ -22,11 +22,11 @@ computation where:
 
 Architecture:
     PublicKey (from crypto.kem_keygen)
-        ↓ quote_gen(pk, platform)
-    Quote[platform]  (cryptographic attestation proof)
+        ↓ quote_gen(pk)
+    Quote  (cryptographic attestation proof)
         ↓ (transfer to verifier)
         ↓ attest(quote)
-    AttestedKey[platform, curve]  (verified TEE public key)
+    AttestedKey[curve]  (verified TEE public key)
         ↓ crypto.kem_derive(local_sk, attested_pk)
     SharedSecret  (secure channel with TEE)
 
@@ -71,7 +71,6 @@ from mplang.v2.edsl import serde
 # --- Type Definitions
 # ==============================================================================
 
-Platform = Literal["mock", "sgx", "tdx", "sev"]
 KeyCurve = Literal["x25519", "secp256k1"]
 
 
@@ -86,37 +85,29 @@ class QuoteType(elt.BaseType):
 
     The quote can be verified by anyone with access to the TEE vendor's
     root certificates (Intel, AMD, etc.).
-
-    Attributes:
-        platform: TEE platform identifier
     """
 
-    def __init__(self, platform: str = "mock"):
-        self.platform: Platform = platform  # type: ignore[assignment]
-
     def __str__(self) -> str:
-        return f"TEEQuote[{self.platform}]"
+        return "TEEQuote"
 
     def __repr__(self) -> str:
-        return f"QuoteType(platform={self.platform!r})"
+        return "QuoteType()"
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, QuoteType):
-            return False
-        return self.platform == other.platform
+        return isinstance(other, QuoteType)
 
     def __hash__(self) -> int:
-        return hash(("QuoteType", self.platform))
+        return hash("QuoteType")
 
     # --- Serde methods ---
     _serde_kind: ClassVar[str] = "tee.QuoteType"
 
     def to_json(self) -> dict[str, Any]:
-        return {"platform": self.platform}
+        return {}
 
     @classmethod
     def from_json(cls, data: dict[str, Any]) -> QuoteType:
-        return cls(platform=data["platform"])
+        return cls()
 
 
 @serde.register_class
@@ -134,37 +125,35 @@ class AttestedKeyType(elt.BaseType):
     3. The public key is bound in the quote's report_data
 
     Attributes:
-        platform: TEE platform that generated the original quote
         curve: Cryptographic curve of the key
     """
 
-    def __init__(self, platform: str = "mock", curve: str = "x25519"):
-        self.platform: Platform = platform  # type: ignore[assignment]
+    def __init__(self, curve: str = "x25519"):
         self.curve: KeyCurve = curve  # type: ignore[assignment]
 
     def __str__(self) -> str:
-        return f"AttestedKey[{self.platform}, {self.curve}]"
+        return f"AttestedKey[{self.curve}]"
 
     def __repr__(self) -> str:
-        return f"AttestedKeyType(platform={self.platform!r}, curve={self.curve!r})"
+        return f"AttestedKeyType(curve={self.curve!r})"
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, AttestedKeyType):
             return False
-        return self.platform == other.platform and self.curve == other.curve
+        return self.curve == other.curve
 
     def __hash__(self) -> int:
-        return hash(("AttestedKeyType", self.platform, self.curve))
+        return hash(("AttestedKeyType", self.curve))
 
     # --- Serde methods ---
     _serde_kind: ClassVar[str] = "tee.AttestedKeyType"
 
     def to_json(self) -> dict[str, Any]:
-        return {"platform": self.platform, "curve": self.curve}
+        return {"curve": self.curve}
 
     @classmethod
     def from_json(cls, data: dict[str, Any]) -> AttestedKeyType:
-        return cls(platform=data["platform"], curve=data["curve"])
+        return cls(curve=data["curve"])
 
 
 @serde.register_class
@@ -173,37 +162,29 @@ class MeasurementType(elt.BaseType):
 
     Represents a cryptographic hash of the code and initial configuration
     running inside the TEE. Used to verify the TEE is running expected code.
-
-    Attributes:
-        platform: TEE platform
     """
 
-    def __init__(self, platform: str = "mock"):
-        self.platform: Platform = platform  # type: ignore[assignment]
-
     def __str__(self) -> str:
-        return f"TEEMeasurement[{self.platform}]"
+        return "TEEMeasurement"
 
     def __repr__(self) -> str:
-        return f"MeasurementType(platform={self.platform!r})"
+        return "MeasurementType()"
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, MeasurementType):
-            return False
-        return self.platform == other.platform
+        return isinstance(other, MeasurementType)
 
     def __hash__(self) -> int:
-        return hash(("MeasurementType", self.platform))
+        return hash("MeasurementType")
 
     # --- Serde methods ---
     _serde_kind: ClassVar[str] = "tee.MeasurementType"
 
     def to_json(self) -> dict[str, Any]:
-        return {"platform": self.platform}
+        return {}
 
     @classmethod
     def from_json(cls, data: dict[str, Any]) -> MeasurementType:
-        return cls(platform=data["platform"])
+        return cls()
 
 
 # ==============================================================================
@@ -223,14 +204,11 @@ get_measurement_p = el.Primitive[el.Object]("tee.get_measurement")
 @quote_gen_p.def_abstract_eval
 def _quote_gen_ae(
     pk: elt.BaseType,
-    *,
-    platform: Platform = "mock",
 ) -> QuoteType:
     """Generate a TEE quote binding the provided public key.
 
     Args:
         pk: Public key to bind in the quote (must be PublicKeyType from crypto.kem_keygen)
-        platform: TEE platform to use
 
     Returns:
         QuoteType representing the attestation proof
@@ -243,7 +221,7 @@ def _quote_gen_ae(
             f"quote_gen expects PublicKeyType (from crypto.kem_keygen), "
             f"got {type(pk).__name__}"
         )
-    return QuoteType(platform=platform)
+    return QuoteType()
 
 
 @attest_p.def_abstract_eval
@@ -261,7 +239,7 @@ def _attest_ae(
     Returns:
         AttestedKeyType containing the verified public key
     """
-    return AttestedKeyType(platform=quote.platform, curve=expected_curve)
+    return AttestedKeyType(curve=expected_curve)
 
 
 @get_measurement_p.def_abstract_eval
@@ -276,7 +254,7 @@ def _get_measurement_ae(
     Returns:
         MeasurementType containing the code measurement
     """
-    return MeasurementType(platform=quote.platform)
+    return MeasurementType()
 
 
 # ==============================================================================
@@ -286,7 +264,6 @@ def _get_measurement_ae(
 
 def quote_gen(
     pk: el.Object,
-    platform: Platform = "mock",
 ) -> el.Object:
     """Generate a TEE attestation quote binding the provided public key.
 
@@ -297,7 +274,6 @@ def quote_gen(
 
     Args:
         pk: Public key to bind (typically from crypto.kem_keygen)
-        platform: TEE platform ("mock", "sgx", "tdx", "sev")
 
     Returns:
         Object[QuoteType] - The attestation quote
@@ -306,7 +282,7 @@ def quote_gen(
         >>> sk, pk = crypto.kem_keygen("x25519")
         >>> quote = tee.quote_gen(pk)  # Bind pk in attestation
     """
-    return quote_gen_p.bind(pk, platform=platform)
+    return quote_gen_p.bind(pk)
 
 
 def attest(
@@ -360,7 +336,6 @@ __all__ = [
     "AttestedKeyType",
     "KeyCurve",
     "MeasurementType",
-    "Platform",
     "QuoteType",
     "attest",
     "attest_p",

{mplang_nightly-0.1.dev258 → mplang_nightly-0.1.dev260}/tests/v2/backends/test_tee_impl.py

@@ -49,11 +49,10 @@ class TestMockTEEExecution:
             _sk, pk = crypto.kem_keygen("x25519")
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
-                quote = tee.quote_gen(pk, platform="mock")
+                quote = tee.quote_gen(pk)
 
             # Verify type propagation
             assert isinstance(quote.type, tee.QuoteType)
-            assert quote.type.platform == "mock"
 
     def test_attest_execution(self):
         """Test attest primitive execution produces correct type.
@@ -65,7 +64,7 @@ class TestMockTEEExecution:
             _sk, pk = crypto.kem_keygen("x25519")
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
-                quote = tee.quote_gen(pk, platform="sgx")
+                quote = tee.quote_gen(pk)
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
                 attested_pk = tee.attest(quote, expected_curve="x25519")
@@ -73,7 +72,6 @@ class TestMockTEEExecution:
             # Type level still shows AttestedKeyType (for type checking)
             # But runtime returns PublicKeyValue directly
             assert isinstance(attested_pk.type, tee.AttestedKeyType)
-            assert attested_pk.type.platform == "sgx"
             assert attested_pk.type.curve == "x25519"
 
     def test_full_attestation_workflow(self):
@@ -82,14 +80,13 @@ class TestMockTEEExecution:
             _sk, pk = crypto.kem_keygen("x25519")
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
-                quote = tee.quote_gen(pk, platform="tdx")
+                quote = tee.quote_gen(pk)
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
                 attested_pk = tee.attest(quote, expected_curve="x25519")
 
             # Verify types propagate correctly through the workflow
             assert isinstance(attested_pk.type, tee.AttestedKeyType)
-            assert attested_pk.type.platform == "tdx"
 
 
 class TestTEEWithCryptoIntegration:
@@ -102,7 +99,7 @@ class TestTEEWithCryptoIntegration:
             tee_sk, tee_pk = crypto.kem_keygen("x25519")
 
             with pytest.warns(UserWarning, match="Insecure mock TEE"):
-                quote = tee.quote_gen(tee_pk, platform="sgx")
+                quote = tee.quote_gen(tee_pk)
 
             # Verifier side: attest and generate own keypair
             with pytest.warns(UserWarning, match="Insecure mock TEE"):

{mplang_nightly-0.1.dev258 → mplang_nightly-0.1.dev260}/tests/v2/dialects/test_tee.py

@@ -24,73 +24,54 @@ from mplang.v2.dialects import crypto, tee
 class TestTEETypes:
     """Test TEE type definitions."""
 
-    def test_quote_type_default(self):
-        """Test QuoteType with default platform."""
+    def test_quote_type(self):
+        """Test QuoteType."""
         qt = tee.QuoteType()
-        assert qt.platform == "mock"
-        assert str(qt) == "TEEQuote[mock]"
-        assert repr(qt) == "QuoteType(platform='mock')"
-
-    def test_quote_type_platforms(self):
-        """Test QuoteType with different platforms."""
-        platforms = ["mock", "sgx", "tdx", "sev"]
-        for platform in platforms:
-            qt = tee.QuoteType(platform=platform)
-            assert qt.platform == platform
-            assert str(qt) == f"TEEQuote[{platform}]"
+        assert str(qt) == "TEEQuote"
+        assert repr(qt) == "QuoteType()"
 
     def test_quote_type_equality(self):
         """Test QuoteType equality and hashing."""
-        q1 = tee.QuoteType("sgx")
-        q2 = tee.QuoteType("sgx")
-        q3 = tee.QuoteType("tdx")
+        q1 = tee.QuoteType()
+        q2 = tee.QuoteType()
 
         assert q1 == q2
-        assert q1 != q3
         assert hash(q1) == hash(q2)
-        assert hash(q1) != hash(q3)
 
-    def test_attested_key_type_default(self):
-        """Test AttestedKeyType with defaults."""
+    def test_attested_key_type(self):
+        """Test AttestedKeyType."""
         akt = tee.AttestedKeyType()
-        assert akt.platform == "mock"
         assert akt.curve == "x25519"
-        assert str(akt) == "AttestedKey[mock, x25519]"
+        assert str(akt) == "AttestedKey[x25519]"
 
     def test_attested_key_type_custom(self):
         """Test AttestedKeyType with custom values."""
-        akt = tee.AttestedKeyType(platform="sgx", curve="secp256k1")
-        assert akt.platform == "sgx"
+        akt = tee.AttestedKeyType(curve="secp256k1")
         assert akt.curve == "secp256k1"
-        assert str(akt) == "AttestedKey[sgx, secp256k1]"
+        assert str(akt) == "AttestedKey[secp256k1]"
 
     def test_attested_key_type_equality(self):
         """Test AttestedKeyType equality and hashing."""
-        a1 = tee.AttestedKeyType("sgx", "x25519")
-        a2 = tee.AttestedKeyType("sgx", "x25519")
-        a3 = tee.AttestedKeyType("sgx", "secp256k1")
-        a4 = tee.AttestedKeyType("tdx", "x25519")
+        a1 = tee.AttestedKeyType("x25519")
+        a2 = tee.AttestedKeyType("x25519")
+        a3 = tee.AttestedKeyType("secp256k1")
 
         assert a1 == a2
         assert a1 != a3  # Different curve
-        assert a1 != a4  # Different platform
         assert hash(a1) == hash(a2)
 
     def test_measurement_type(self):
         """Test MeasurementType."""
-        mt = tee.MeasurementType(platform="sgx")
-        assert mt.platform == "sgx"
-        assert str(mt) == "TEEMeasurement[sgx]"
-        assert repr(mt) == "MeasurementType(platform='sgx')"
+        mt = tee.MeasurementType()
+        assert str(mt) == "TEEMeasurement"
+        assert repr(mt) == "MeasurementType()"
 
     def test_measurement_type_equality(self):
         """Test MeasurementType equality."""
-        m1 = tee.MeasurementType("sgx")
-        m2 = tee.MeasurementType("sgx")
-        m3 = tee.MeasurementType("tdx")
+        m1 = tee.MeasurementType()
+        m2 = tee.MeasurementType()
 
         assert m1 == m2
-        assert m1 != m3
         assert hash(m1) == hash(m2)
 
 
@@ -111,26 +92,12 @@ class TestTEETypeInference:
         quote_op = graph.operations[1]
         assert quote_op.opcode == "tee.quote_gen"
 
-    def test_quote_gen_with_platform(self):
-        """Test quote_gen with explicit platform."""
-
-        def workflow():
-            _sk, pk = crypto.kem_keygen("x25519")
-            quote = tee.quote_gen(pk, platform="sgx")
-            return quote
-
-        traced = el.trace(workflow)
-        graph = traced.graph
-
-        quote_op = graph.operations[1]
-        assert quote_op.attrs["platform"] == "sgx"
-
     def test_attest_in_graph(self):
         """Test attest creates correct graph operation."""
 
         def workflow():
             _sk, pk = crypto.kem_keygen("x25519")
-            quote = tee.quote_gen(pk, platform="sgx")
+            quote = tee.quote_gen(pk)
             attested_pk = tee.attest(quote, expected_curve="secp256k1")
             return attested_pk
 
@@ -147,7 +114,7 @@ class TestTEETypeInference:
 
         def workflow():
             _sk, pk = crypto.kem_keygen("x25519")
-            quote = tee.quote_gen(pk, platform="sev")
+            quote = tee.quote_gen(pk)
             measurement = tee.get_measurement(quote)
             return measurement
 
@@ -163,7 +130,7 @@ class TestTEETypeInference:
 
         def workflow():
             _sk, pk = crypto.kem_keygen("x25519")
-            quote = tee.quote_gen(pk, platform="tdx")
+            quote = tee.quote_gen(pk)
             attested_pk = tee.attest(quote)
             measurement = tee.get_measurement(quote)
             return attested_pk, measurement