kya-validator 0.2.3

Rust core KYA (Know Your Agent) validator with Python bindings, TEE support, and blockchain integration
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

"""
TEE (Trusted Execution Environment) verification API.

This module provides interfaces for verifying TEE attestation
evidence from Intel SGX and AMD SEV-SNP.
"""

from typing import Optional
from .types import TeeEvidence, TeeReport
from .errors import TeeVerificationError


class TeeVerifier:
    """TEE attestation evidence verifier.

    This class provides methods for verifying TEE evidence
    from Intel SGX and AMD SEV-SNP.

    Examples
    --------
    >>> verifier = TeeVerifier()
    >>> evidence = TeeEvidence(
    ...     attestation_type='intel-sgx',
    ...     quote='base64encodedquote...'
    ... )
    >>> report = verifier.verify(evidence)
    >>> print(report.valid)
    True
    """

    def __init__(self):
        """Initialize TEE verifier."""
        # Placeholder for future PyO3 bindings
        pass

    def verify(self, evidence: TeeEvidence) -> TeeReport:
        """Verify TEE attestation evidence.

        Parameters
        ----------
        evidence : TeeEvidence
            TEE evidence to verify.

        Returns
        -------
        TeeReport
            Verification report with results.

        Raises
        ------
        TeeVerificationError
            If verification fails.

        Examples
        --------
        >>> evidence = TeeEvidence(
        ...     attestation_type='intel-sgx',
        ...     quote='base64encodedquote...'
        ... )
        >>> report = verifier.verify(evidence)
        """
        # Placeholder for future PyO3 bindings
        # In production, this will call Rust verify_tee_evidence
        return TeeReport(
            valid=False,
            tee_type=evidence.attestation_type,
            mr_enclave='not_implemented',
            mr_signer='not_implemented',
            product_id=0,
            svn=0,
            report_data_match=False,
            errors=['TEE verification not yet implemented in Python layer'],
            info=['Use Rust core for full verification'],
        )

    def verify_sgx(
        self,
        quote: str,
        mr_enclave: Optional[str] = None,
        mr_signer: Optional[str] = None,
        product_id: Optional[int] = None,
        min_svn: Optional[int] = None,
    ) -> TeeReport:
        """Verify Intel SGX attestation quote.

        Parameters
        ----------
        quote : str
            Base64-encoded SGX quote.
        mr_enclave : str, optional
            Expected MR Enclave value.
        mr_signer : str, optional
            Expected MR Signer value.
        product_id : int, optional
            Expected Product ID.
        min_svn : int, optional
            Minimum Security Version Number.

        Returns
        -------
        TeeReport
            Verification report.

        Raises
        ------
        TeeVerificationError
            If verification fails.
        """
        evidence = TeeEvidence(
            attestation_type='intel-sgx',
            quote=quote,
            mr_enclave=mr_enclave,
            mr_signer=mr_signer,
            product_id=product_id,
            min_svn=min_svn,
        )
        return self.verify(evidence)

    def verify_sev_snp(
        self,
        quote: str,
        report_data: Optional[str] = None,
    ) -> TeeReport:
        """Verify AMD SEV-SNP attestation quote.

        Parameters
        ----------
        quote : str
            Base64-encoded SEV-SNP quote.
        report_data : str, optional
            Expected report data.

        Returns
        -------
        TeeReport
            Verification report.

        Raises
        ------
        TeeVerificationError
            If verification fails.
        """
        evidence = TeeEvidence(
            attestation_type='amd-sev-snp',
            quote=quote,
            report_data=report_data,
        )
        return self.verify(evidence)


def verify_tee_evidence(evidence: TeeEvidence) -> TeeReport:
    """Verify TEE attestation evidence (convenience function).

    This is a convenience function that creates a TeeVerifier
    and verifies the evidence.

    Parameters
    ----------
    evidence : TeeEvidence
        TEE evidence to verify.

    Returns
    -------
    TeeReport
        Verification report with results.

    Raises
    ------
    TeeVerificationError
        If verification fails.

    Examples
    --------
    >>> evidence = TeeEvidence(
    ...     attestation_type='intel-sgx',
    ...     quote='base64encodedquote...'
    ... )
    >>> report = verify_tee_evidence(evidence)
    >>> print(report.valid)
    True
    """
    verifier = TeeVerifier()
    return verifier.verify(evidence)