dcap-qvl 0.3.9

This crate implements the quote verification logic for DCAP (Data Center Attestation Primitives) in pure Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

# DCAP-QVL Python Bindings

This directory contains the Python bindings for the DCAP-QVL (Data Center Attestation Primitives Quote Verification Library) implemented in Rust.

## Directory Structure

```
python-bindings/
├── README.md                    # This file
├── pyproject.toml              # Python project configuration
├── uv.lock                     # uv lock file
├── python/                     # Python package source
│   └── dcap_qvl/
│       ├── __init__.py         # Main package with async API
├── examples/                   # Example scripts
│   ├── basic_test.py          # Basic functionality test
│   └── python_example.py      # Real-world usage example
├── tests/                      # All test files
│   ├── test_python_bindings.py      # Basic Python binding tests
│   ├── test_collateral_api.py       # Async collateral API tests
│   ├── test_all_async_functions.py  # Comprehensive async tests
│   ├── test_with_samples.py         # Tests with real sample data
│   ├── test_async_collateral.py     # Basic async collateral tests
│   ├── test_python_versions.sh      # Multi-version testing script
│   ├── test_cross_versions.sh       # Cross-version compatibility
│   └── test_installation.py         # Installation verification
├── scripts/                    # Build scripts
│   ├── build_wheels.py        # Wheel building script
│   └── build_wheels.sh         # Wheel building shell script
└── docs/                       # Documentation
    ├── README_Python.md        # Main Python bindings documentation
    ├── PYTHON_TESTING.md        # Python version testing guide
    └── BUILDING.md              # Build instructions
```

## Quick Start

### Building and Testing

```bash
# From the project root directory
make build_python                    # Build Python bindings
make test_python                     # Test basic functionality
make test_python_versions            # Test across Python versions

# Or directly from this directory
cd python-bindings
uv run maturin develop --features python
uv run python examples/basic_test.py
```

### Installation

```bash
# Using uv (recommended)
cd python-bindings
uv sync
uv run maturin develop --features python

# Using pip with maturin
pip install maturin
cd python-bindings
maturin develop --features python
```

## Features

- **Python 3.8+ Support**: Compatible with Python 3.8 through 3.13
- **Async API**: Full async/await support for collateral fetching and verification
- **Modern Tooling**: Uses uv for package management and maturin for building
- **Comprehensive Testing**: Automated testing across all supported Python versions
- **Clean API**: Pythonic async interface to the Rust library
- **Type Safety**: Proper error handling and type annotations with async support

## API Overview

```python
import asyncio
import dcap_qvl

async def main():
    # Get collateral from Intel PCS (async)
    quote_data = open("quote.bin", "rb").read()
    collateral = await dcap_qvl.get_collateral_from_pcs(quote_data)
    
    # Or get collateral for specific FMSPC (async)
    collateral = await dcap_qvl.get_collateral_for_fmspc(
        pccs_url="https://api.trustedservices.intel.com",
        fmspc="B0C06F000000",
        ca="processor",
        is_sgx=True
    )
    
    # Verify quote with collateral
    result = dcap_qvl.verify(quote_data, collateral, timestamp)
    print(f"Status: {result.status}")
    
    # Or get collateral and verify in one step (async)
    result = await dcap_qvl.get_collateral_and_verify(quote_data)
    print(f"Advisory IDs: {result.advisory_ids}")

# Run async code
asyncio.run(main())
```

## Documentation

- **[README_Python.md](docs/README_Python.md)**: Complete API documentation and usage guide
- **[PYTHON_TESTING.md](docs/PYTHON_TESTING.md)**: Python version compatibility testing guide

## Development

The Python bindings are built using:

- **[PyO3](https://pyo3.rs/)**: Rust bindings for Python
- **[maturin](https://github.com/PyO3/maturin)**: Build tool for Rust-based Python extensions
- **[uv](https://github.com/astral-sh/uv)**: Modern Python package management

### Adding New Features

1. Add Rust implementation in `../src/python.rs`
2. Update Python package in `python/dcap_qvl/__init__.py`
3. Add tests in `tests/` directory (use appropriate test file)
5. Update documentation in `docs/`

### Testing

The project includes comprehensive testing:

- **Unit tests**: Basic functionality testing with pytest
- **Async tests**: Full async/await testing with pytest-asyncio
- **Integration tests**: Real-world usage scenarios with sample data
- **Version compatibility**: Testing across Python 3.8-3.13
- **Cross-version testing**: Automated testing across multiple Python versions
- **CI/CD**: Automated testing in GitHub Actions

## Requirements

- Python 3.8+
- Rust toolchain (for building)
- uv (recommended) or pip with maturin

## License

MIT License - see [../LICENSE](../LICENSE) for details.