dcap-qvl 0.3.0__cp37-abi3-macosx_11_0_arm64.whl

dcap_qvl/__init__.py

@@ -0,0 +1,204 @@
+"""
+DCAP Quote Verification Library
+
+This package provides Python bindings for the DCAP (Data Center Attestation Primitives)
+quote verification library implemented in Rust.
+
+Main classes:
+- QuoteCollateralV3: Represents quote collateral data
+- VerifiedReport: Contains verification results
+
+Main functions:
+- verify: Verify a quote with collateral data
+- get_collateral: Get collateral from PCCS URL
+- get_collateral_from_pcs: Get collateral from Intel PCS
+- get_collateral_and_verify: Get collateral and verify quote
+"""
+
+import time
+import json
+from typing import Optional, Union
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+from .dcap_qvl import (
+    PyQuoteCollateralV3 as QuoteCollateralV3,
+    PyVerifiedReport as VerifiedReport,
+    PyQuote as Quote,
+    py_verify as verify,
+    parse_quote,
+)
+
+# Default Intel PCS URL
+PCS_URL = "https://api.trustedservices.intel.com"
+
+
+# Note: These functions are now implemented in Rust and imported above
+# The manual parsing logic has been replaced with proper Rust-based parsing
+
+
+def _make_pcs_request(url: str) -> bytes:
+    """Make HTTP request to PCS endpoint."""
+    if requests is None:
+        raise ImportError(
+            "requests library is required for collateral fetching. Install with: pip install requests")
+
+    try:
+        response = requests.get(url, timeout=30, verify=False)
+        response.raise_for_status()
+        return response.content
+    except requests.RequestException as e:
+        raise RuntimeError(f"Failed to fetch from {url}: {e}")
+
+
+def get_collateral(pccs_url: str, raw_quote: bytes) -> QuoteCollateralV3:
+    """Get collateral from PCCS URL.
+
+    Args:
+        pccs_url: PCCS server URL
+        raw_quote: Raw quote bytes
+
+    Returns:
+        QuoteCollateralV3: Quote collateral data
+
+    Raises:
+        ValueError: If quote is invalid or FMSPC cannot be extracted
+        RuntimeError: If network request fails
+        ImportError: If requests library is not available
+    """
+    if not isinstance(raw_quote, (bytes, bytearray)):
+        raise TypeError("raw_quote must be bytes")
+
+    quote = Quote.parse(raw_quote)
+    # Extract FMSPC from quote
+    fmspc = quote.fmspc()
+
+    # Determine if SGX or TDX
+    is_tdx = quote.is_tdx()
+    ca = quote.ca()
+
+    # Build PCS endpoints
+    base_url = pccs_url.rstrip('/')
+
+    if is_tdx:
+        # TDX endpoints
+        pckcrl_url = f"{base_url}/tdx/certification/v4/pckcrl?ca={ca}&encoding=der"
+        rootcacrl_url = f"{base_url}/tdx/certification/v4/rootcacrl"
+        tcb_url = f"{base_url}/tdx/certification/v4/tcb?fmspc={fmspc}"
+        qe_identity_url = f"{base_url}/tdx/certification/v4/qe/identity?update=standard"
+    else:
+        # SGX endpoints
+        pckcrl_url = f"{base_url}/sgx/certification/v4/pckcrl?ca={ca}&encoding=der"
+        rootcacrl_url = f"{base_url}/sgx/certification/v4/rootcacrl"
+        tcb_url = f"{base_url}/sgx/certification/v4/tcb?fmspc={fmspc}"
+        qe_identity_url = f"{base_url}/sgx/certification/v4/qe/identity?update=standard"
+
+    # Fetch collateral data
+    try:
+        # Get PCK CRL and issuer chain
+        pckcrl_response = _make_pcs_request(pckcrl_url)
+        pck_crl = pckcrl_response
+        pck_crl_issuer_chain = ""  # Would need to parse from response headers
+
+        # Get Root CA CRL
+        root_ca_crl = _make_pcs_request(rootcacrl_url)
+
+        # Get TCB Info
+        tcb_response = _make_pcs_request(tcb_url)
+        tcb_data = json.loads(tcb_response.decode('utf-8'))
+        tcb_info = json.dumps(tcb_data.get('tcbInfo', {}))
+        tcb_info_issuer_chain = ""  # Would need to parse from response headers
+
+        # Extract TCB signature
+        tcb_signature_hex = tcb_data.get('signature', '')
+        tcb_info_signature = bytes.fromhex(
+            tcb_signature_hex) if tcb_signature_hex else b''
+
+        # Get QE Identity
+        qe_response = _make_pcs_request(qe_identity_url)
+        qe_data = json.loads(qe_response.decode('utf-8'))
+        qe_identity = json.dumps(qe_data.get('enclaveIdentity', {}))
+        qe_identity_issuer_chain = ""  # Would need to parse from response headers
+
+        # Extract QE signature
+        qe_signature_hex = qe_data.get('signature', '')
+        qe_identity_signature = bytes.fromhex(
+            qe_signature_hex) if qe_signature_hex else b''
+
+        return QuoteCollateralV3(
+            pck_crl_issuer_chain=pck_crl_issuer_chain,
+            root_ca_crl=root_ca_crl,
+            pck_crl=pck_crl,
+            tcb_info_issuer_chain=tcb_info_issuer_chain,
+            tcb_info=tcb_info,
+            tcb_info_signature=tcb_info_signature,
+            qe_identity_issuer_chain=qe_identity_issuer_chain,
+            qe_identity=qe_identity,
+            qe_identity_signature=qe_identity_signature,
+        )
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to get collateral: {e}")
+
+
+def get_collateral_from_pcs(raw_quote: bytes) -> QuoteCollateralV3:
+    """Get collateral from Intel PCS.
+
+    Args:
+        raw_quote: Raw quote bytes
+
+    Returns:
+        QuoteCollateralV3: Quote collateral data
+
+    Raises:
+        ValueError: If quote is invalid or FMSPC cannot be extracted
+        RuntimeError: If network request fails
+        ImportError: If requests library is not available
+    """
+    return get_collateral(PCS_URL, raw_quote)
+
+
+def get_collateral_and_verify(raw_quote: bytes, pccs_url: Optional[str] = None) -> VerifiedReport:
+    """Get collateral and verify the quote.
+
+    Args:
+        raw_quote: Raw quote bytes
+        pccs_url: Optional PCCS URL (defaults to Intel PCS)
+
+    Returns:
+        VerifiedReport: Verification result
+
+    Raises:
+        ValueError: If quote is invalid or verification fails
+        RuntimeError: If network request fails
+        ImportError: If requests library is not available
+    """
+    # Use provided PCCS URL or default to Intel PCS
+    url = pccs_url.strip() if pccs_url else PCS_URL
+    if not url:
+        url = PCS_URL
+
+    # Get collateral
+    collateral = get_collateral(url, raw_quote)
+
+    # Get current time
+    now_secs = int(time.time())
+
+    # Verify quote
+    return verify(raw_quote, collateral, now_secs)
+
+
+__all__ = [
+    "QuoteCollateralV3",
+    "VerifiedReport",
+    "Quote",
+    "verify",
+    "get_collateral",
+    "get_collateral_from_pcs",
+    "get_collateral_and_verify",
+]
+
+__version__ = "0.3.0"

dcap_qvl/__init__.pyi

@@ -0,0 +1,334 @@
+"""
+Type stubs for dcap_qvl Python bindings.
+
+This file provides type hints for the compiled Rust extension, enabling better
+IDE support, type checking with mypy, and improved developer experience.
+"""
+
+from typing import List
+
+__version__: str
+__all__: List[str]
+
+
+class QuoteCollateralV3:
+    """
+    Represents quote collateral data required for DCAP quote verification.
+
+    This class contains all the necessary certificate chains, CRLs, and
+    attestation information needed to verify an SGX or TDX quote.
+    """
+
+    def __init__(
+        self,
+        pck_crl_issuer_chain: str,
+        root_ca_crl: bytes,
+        pck_crl: bytes,
+        tcb_info_issuer_chain: str,
+        tcb_info: str,
+        tcb_info_signature: bytes,
+        qe_identity_issuer_chain: str,
+        qe_identity: str,
+        qe_identity_signature: bytes,
+    ) -> None:
+        """
+        Create a new QuoteCollateralV3 instance.
+
+        Args:
+            pck_crl_issuer_chain: PCK CRL issuer certificate chain (PEM format)
+            root_ca_crl: Root CA certificate revocation list
+            pck_crl: PCK certificate revocation list
+            tcb_info_issuer_chain: TCB info issuer certificate chain (PEM format)
+            tcb_info: TCB (Trusted Computing Base) information (JSON string)
+            tcb_info_signature: Signature for the TCB info
+            qe_identity_issuer_chain: QE identity issuer certificate chain (PEM format)
+            qe_identity: Quoting Enclave identity information (JSON string)
+            qe_identity_signature: Signature for the QE identity
+        """
+        ...
+
+    @property
+    def pck_crl_issuer_chain(self) -> str:
+        """PCK CRL issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def root_ca_crl(self) -> bytes:
+        """Root CA certificate revocation list."""
+        ...
+
+    @property
+    def pck_crl(self) -> bytes:
+        """PCK certificate revocation list."""
+        ...
+
+    @property
+    def tcb_info_issuer_chain(self) -> str:
+        """TCB info issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def tcb_info(self) -> str:
+        """TCB (Trusted Computing Base) information as JSON string."""
+        ...
+
+    @property
+    def tcb_info_signature(self) -> bytes:
+        """Signature for the TCB info."""
+        ...
+
+    @property
+    def qe_identity_issuer_chain(self) -> str:
+        """QE identity issuer certificate chain in PEM format."""
+        ...
+
+    @property
+    def qe_identity(self) -> str:
+        """Quoting Enclave identity information as JSON string."""
+        ...
+
+    @property
+    def qe_identity_signature(self) -> bytes:
+        """Signature for the QE identity."""
+        ...
+
+    def to_json(self) -> str:
+        """
+        Serialize the collateral to a JSON string.
+
+        Returns:
+            JSON string representation of the collateral data
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        ...
+
+    @staticmethod
+    def from_json(json_str: str) -> "QuoteCollateralV3":
+        """
+        Create a QuoteCollateralV3 instance from a JSON string.
+
+        Args:
+            json_str: JSON string containing collateral data
+
+        Returns:
+            New QuoteCollateralV3 instance
+
+        Raises:
+            ValueError: If JSON parsing fails or data is invalid
+        """
+        ...
+
+
+class VerifiedReport:
+    """
+    Contains the results of DCAP quote verification.
+
+    This class holds the verification status and any security advisories
+    that were found during the quote verification process.
+    """
+
+    @property
+    def status(self) -> str:
+        """
+        Verification status string.
+
+        Common values include:
+        - "OK": Verification successful, no issues
+        - "SW_HARDENING_NEEDED": Software hardening recommended
+        - "CONFIGURATION_NEEDED": Platform configuration required
+        - "OUT_OF_DATE": TCB is out of date
+        - "REVOKED": Certificate or key has been revoked
+        """
+        ...
+
+    @property
+    def advisory_ids(self) -> List[str]:
+        """
+        List of security advisory IDs that apply to this quote.
+
+        These are Intel security advisory identifiers (e.g., "INTEL-SA-00334")
+        that indicate known security issues affecting the attested platform.
+        """
+        ...
+
+    def to_json(self) -> str:
+        """
+        Serialize the verification report to a JSON string.
+
+        Returns:
+            JSON string representation of the verification report
+
+        Raises:
+            ValueError: If serialization fails
+        """
+        ...
+
+
+class Quote:
+    """
+    Represents a parsed SGX or TDX quote.
+
+    This class provides access to quote metadata and identifiers
+    without requiring collateral data for verification.
+    """
+
+    @staticmethod
+    def parse(raw_quote: bytes) -> "Quote":
+        """
+        Parse a raw quote from bytes.
+
+        Args:
+            raw_quote: Raw quote data as bytes (SGX or TDX format)
+
+        Returns:
+            Quote instance with parsed quote data
+
+        Raises:
+            ValueError: If quote parsing fails due to invalid format or corrupted data
+
+        Example:
+            >>> import dcap_qvl
+            >>>
+            >>> with open("quote.bin", "rb") as f:
+            ...     quote_data = f.read()
+            >>>
+            >>> quote = dcap_qvl.Quote.parse(quote_data)
+            >>> print(f"Quote type: {quote.quote_type()}")
+            >>> print(f"FMSPC: {quote.fmspc()}")
+        """
+        ...
+
+    def fmspc(self) -> str:
+        """
+        Extract the FMSPC (Family-Model-Stepping-Platform-CustomSKU) identifier.
+
+        The FMSPC is a 6-byte identifier that uniquely identifies the
+        platform's TCB level and is used for collateral retrieval.
+
+        Returns:
+            FMSPC as uppercase hexadecimal string (12 characters)
+
+        Raises:
+            ValueError: If FMSPC cannot be extracted from the quote
+
+        Example:
+            >>> quote = dcap_qvl.Quote.parse(quote_data)
+            >>> fmspc = quote.fmspc()
+            >>> print(f"FMSPC: {fmspc}")  # e.g., "00606A000000"
+        """
+        ...
+
+    def ca(self) -> str:
+        """
+        Extract the CA (Certificate Authority) identifier.
+
+        The CA identifier indicates which certificate authority
+        should be used for quote verification.
+
+        Returns:
+            CA identifier as string
+
+        Raises:
+            ValueError: If CA identifier cannot be extracted from the quote
+        """
+        ...
+
+    def is_tdx(self) -> bool:
+        """
+        Check if this is a TDX (Trust Domain Extensions) quote.
+
+        Returns:
+            True if the quote is TDX format, False if SGX format
+
+        Example:
+            >>> quote = dcap_qvl.Quote.parse(quote_data)
+            >>> if quote.is_tdx():
+            ...     print("This is a TDX quote")
+            ... else:
+            ...     print("This is an SGX quote")
+        """
+        ...
+
+    def quote_type(self) -> str:
+        """
+        Get the quote type as a string.
+
+        Returns:
+            "TDX" for TDX quotes, "SGX" for SGX quotes
+
+        Example:
+            >>> quote = dcap_qvl.Quote.parse(quote_data)
+            >>> print(f"Quote type: {quote.quote_type()}")
+        """
+        ...
+
+# Synchronous functions
+
+
+def verify(
+    raw_quote: bytes,
+    collateral: QuoteCollateralV3,
+    now_secs: int
+) -> VerifiedReport:
+    """
+    Verify an SGX or TDX quote with the provided collateral data.
+
+    This function performs cryptographic verification of the quote against
+    the provided collateral information, checking certificates, signatures,
+    and revocation status.
+
+    Args:
+        raw_quote: Raw quote data as bytes (SGX or TDX format)
+        collateral: Quote collateral containing certificates and attestation data
+        now_secs: Current timestamp in seconds since Unix epoch for time-based checks
+
+    Returns:
+        VerifiedReport containing verification status and advisory information
+
+    Raises:
+        ValueError: If verification fails due to invalid data, expired certificates,
+                   revoked keys, or other verification errors
+
+    Example:
+        >>> import dcap_qvl
+        >>> import time
+        >>>
+        >>> # Load quote and collateral data
+        >>> with open("quote.bin", "rb") as f:
+        ...     quote_data = f.read()
+        >>>
+        >>> collateral = dcap_qvl.QuoteCollateralV3.from_json(collateral_json)
+        >>> result = dcap_qvl.verify(quote_data, collateral, int(time.time()))
+        >>> print(f"Status: {result.status}")
+    """
+    ...
+
+
+def parse_quote(raw_quote: bytes) -> Quote:
+    """
+    Parse a raw quote from bytes (convenience function).
+
+    This is a convenience function that calls Quote.parse() directly.
+
+    Args:
+        raw_quote: Raw quote data as bytes (SGX or TDX format)
+
+    Returns:
+        Quote instance with parsed quote data
+
+    Raises:
+        ValueError: If quote parsing fails due to invalid format or corrupted data
+
+    Example:
+        >>> import dcap_qvl
+        >>>
+        >>> with open("quote.bin", "rb") as f:
+        ...     quote_data = f.read()
+        >>>
+        >>> quote = dcap_qvl.parse_quote(quote_data)
+        >>> print(f"Quote type: {quote.quote_type()}")
+        >>> print(f"FMSPC: {quote.fmspc()}")
+    """
+    ...

dcap_qvl-0.3.0.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.4
+Name: dcap-qvl
+Version: 0.3.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Summary: Python bindings for DCAP (Data Center Attestation Primitives) quote verification library
+Keywords: sgx,tdx,dcap,attestation,verification,cryptography
+Author-email: Kevin Wang <wy721@qq.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Phala-Network/dcap-qvl
+Project-URL: Repository, https://github.com/Phala-Network/dcap-qvl
+Project-URL: Issues, https://github.com/Phala-Network/dcap-qvl/issues
+
+# Python Bindings for DCAP-QVL
+
+This package provides Python bindings for the DCAP (Data Center Attestation Primitives) quote verification library implemented in Rust.
+
+## Quick Start
+
+```bash
+# Install from PyPI
+pip install dcap-qvl
+
+# Basic usage
+python -c "
+import dcap_qvl
+print('DCAP-QVL Python bindings successfully installed!')
+print(f'Available functions: {dcap_qvl.__all__}')
+"
+```
+
+## Features
+
+- Verify SGX and TDX quotes
+- Handle quote collateral data
+- Parse verification results
+- Pure Rust implementation with Python bindings
+- Cross-platform compatibility (Linux, macOS, Windows)
+- Synchronous collateral fetching from PCCS/PCS
+- Compatible with Python 3.8+
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install dcap-qvl
+```
+
+### Using uv
+
+```bash
+uv add dcap-qvl
+```
+
+## Usage
+
+### Basic Quote Verification
+
+```python
+import dcap_qvl
+import json
+import time
+
+# Load quote data (binary)
+with open("path/to/quote", "rb") as f:
+    quote_data = f.read()
+
+# Load collateral data (JSON)
+with open("path/to/collateral.json", "r") as f:
+    collateral_json = json.load(f)
+
+# Create collateral object
+collateral = dcap_qvl.QuoteCollateralV3.from_json(json.dumps(collateral_json))
+
+# Verify the quote
+now = int(time.time())
+try:
+    result = dcap_qvl.verify(quote_data, collateral, now)
+    print(f"Verification successful! Status: {result.status}")
+    print(f"Advisory IDs: {result.advisory_ids}")
+except ValueError as e:
+    print(f"Verification failed: {e}")
+```
+
+### Working with Collateral Data
+
+```python
+# Create collateral manually
+collateral = dcap_qvl.QuoteCollateralV3(
+    pck_crl_issuer_chain="...",
+    root_ca_crl=b"...",  # bytes
+    pck_crl=b"...",      # bytes
+    tcb_info_issuer_chain="...",
+    tcb_info="...",      # JSON string
+    tcb_info_signature=b"...",  # bytes
+    qe_identity_issuer_chain="...",
+    qe_identity="...",   # JSON string
+    qe_identity_signature=b"...",  # bytes
+)
+
+# Serialize to JSON
+json_str = collateral.to_json()
+
+# Deserialize from JSON
+collateral = dcap_qvl.QuoteCollateralV3.from_json(json_str)
+```
+
+## API Reference
+
+### Collateral Functions
+
+#### `get_collateral(pccs_url: str, raw_quote: bytes) -> QuoteCollateralV3`
+
+Get collateral from a custom PCCS URL.
+
+**Parameters:**
+- `pccs_url`: PCCS URL (e.g., "https://api.trustedservices.intel.com")
+- `raw_quote`: Raw quote data as bytes
+
+**Returns:**
+- `QuoteCollateralV3`: Quote collateral data
+
+**Raises:**
+- `ValueError`: If quote is invalid or FMSPC cannot be extracted
+- `RuntimeError`: If network request fails
+- `ImportError`: If requests library is not available
+
+**Example:**
+```python
+import dcap_qvl
+
+pccs_url = "https://api.trustedservices.intel.com"
+quote_data = open("quote.bin", "rb").read()
+collateral = dcap_qvl.get_collateral(pccs_url, quote_data)
+print(f"Got collateral: {len(collateral.tcb_info)} chars")
+```
+
+#### `get_collateral_from_pcs(raw_quote: bytes) -> QuoteCollateralV3`
+
+Get collateral from Intel's PCS (default).
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+
+**Returns:**
+- `QuoteCollateralV3`: Quote collateral data
+
+**Raises:**
+- `ValueError`: If quote is invalid or FMSPC cannot be extracted
+- `RuntimeError`: If network request fails
+- `ImportError`: If requests library is not available
+
+#### `get_collateral_and_verify(raw_quote: bytes, pccs_url: Optional[str] = None) -> VerifiedReport`
+
+Get collateral and verify quote in one step.
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+- `pccs_url`: Optional PCCS URL (uses Intel PCS if None)
+
+**Returns:**
+- `VerifiedReport`: Verification results
+
+**Raises:**
+- `ValueError`: If quote is invalid or verification fails
+- `RuntimeError`: If network request fails
+- `ImportError`: If requests library is not available
+
+**Example:**
+```python
+import dcap_qvl
+
+quote_data = open("quote.bin", "rb").read()
+result = dcap_qvl.get_collateral_and_verify(quote_data)
+print(f"Status: {result.status}")
+print(f"Advisory IDs: {result.advisory_ids}")
+```
+
+### Classes
+
+#### `QuoteCollateralV3`
+
+Represents quote collateral data required for verification.
+
+**Constructor:**
+```python
+QuoteCollateralV3(
+    pck_crl_issuer_chain: str,
+    root_ca_crl: bytes,
+    pck_crl: bytes,
+    tcb_info_issuer_chain: str,
+    tcb_info: str,
+    tcb_info_signature: bytes,
+    qe_identity_issuer_chain: str,
+    qe_identity: str,
+    qe_identity_signature: bytes,
+)
+```
+
+**Methods:**
+- `to_json() -> str`: Serialize to JSON string
+- `from_json(json_str: str) -> QuoteCollateralV3`: Create from JSON string (static method)
+
+**Properties:**
+- `pck_crl_issuer_chain: str`
+- `root_ca_crl: bytes`
+- `pck_crl: bytes`
+- `tcb_info_issuer_chain: str`
+- `tcb_info: str`
+- `tcb_info_signature: bytes`
+- `qe_identity_issuer_chain: str`
+- `qe_identity: str`
+- `qe_identity_signature: bytes`
+
+#### `VerifiedReport`
+
+Contains the results of quote verification.
+
+**Properties:**
+- `status: str`: Verification status
+- `advisory_ids: List[str]`: List of advisory IDs
+
+**Methods:**
+- `to_json() -> str`: Serialize to JSON string
+
+### Functions
+
+#### `verify(raw_quote: bytes, collateral: QuoteCollateralV3, now_secs: int) -> VerifiedReport`
+
+Verify a quote with the provided collateral data.
+
+**Parameters:**
+- `raw_quote`: Raw quote data as bytes
+- `collateral`: Quote collateral data
+- `now_secs`: Current timestamp in seconds since Unix epoch
+
+**Returns:**
+- `VerifiedReport`: Verification results
+
+**Raises:**
+- `ValueError`: If verification fails
+
+## Development
+
+### Building from Source
+
+If you want to build from source or contribute to development:
+
+```bash
+# Clone the repository
+git clone https://github.com/Phala-Network/dcap-qvl.git
+cd dcap-qvl/python-bindings
+
+# Install development dependencies (including maturin)
+uv sync
+
+# Build and install the Python extension in development mode
+uv run maturin develop --features python
+
+# Run tests
+uv run python -m pytest tests/test_python_bindings.py
+```
+
+**Note:** maturin is only required for building from source. Regular users installing from PyPI don't need maturin.
+
+### Running Examples
+
+After installing the package, you can run the examples:
+
+```bash
+# Download the examples from the repository
+git clone https://github.com/Phala-Network/dcap-qvl.git
+cd dcap-qvl/python-bindings
+
+# Basic functionality test
+python examples/basic_test.py
+
+# Full example (requires sample data files)
+python examples/python_example.py
+```
+
+Or if you're using uv for development:
+
+```bash
+# Basic functionality test
+uv run python examples/basic_test.py
+
+# Full example (requires sample data files)
+uv run python examples/python_example.py
+```
+
+### Testing Across Python Versions
+
+The project includes comprehensive testing across all supported Python versions:
+
+```bash
+# Quick test across all Python versions
+make test_python_versions
+
+# Test current Python version only
+make test_python
+```
+
+See [PYTHON_TESTING.md](PYTHON_TESTING.md) for detailed information about Python version compatibility testing.
+
+## Requirements
+
+### For regular usage (installing from PyPI):
+- Python 3.8+
+
+### For development (building from source):
+- Python 3.8+
+- Rust toolchain (rustc, cargo)
+- maturin (automatically installed with `uv sync`)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

dcap_qvl-0.3.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+dcap_qvl-0.3.0.dist-info/METADATA,sha256=kvyMT6Itp-hO2M6MYH4PJf7I6bPgg76zBgt7vVn_tq8,8444
+dcap_qvl-0.3.0.dist-info/WHEEL,sha256=UYFO5QaLVupuR-8PjNErl5r8k6RNsE-tnSPUE-nT_d4,102
+dcap_qvl/__init__.py,sha256=97qhIqmR6uq7C4AszgmAPP7LcLekvKZOFYmaT3yAaJM,6361
+dcap_qvl/__init__.pyi,sha256=_4GK8CWuFUeewS8ZKk9kiy96hXn4ypDc2rnFpY0g6bQ,9362
+dcap_qvl/dcap_qvl.abi3.so,sha256=TQ1WzAChRR_p4FlRk2C58_ga45hv46MAbivY2vhPXOA,5236016
+dcap_qvl-0.3.0.dist-info/RECORD,,

dcap_qvl-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.2)
+Root-Is-Purelib: false
+Tag: cp37-abi3-macosx_11_0_arm64