Signature Verification

import requests

# 1. Make request
response = requests.post(
    "https://api.redpill.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "phala/qwen-2.5-7b-instruct",
        "messages": [{"role": "user", "content": "Hello"}]
    }
)
request_id = response.json()["id"]

# 2. Get signature
sig_response = requests.get(
    f"https://api.redpill.ai/v1/signature/{request_id}",
    params={"model": "phala/qwen-2.5-7b-instruct"},
    headers={"Authorization": f"Bearer {API_KEY}"}
)
signature_data = sig_response.json()

from hashlib import sha256

def sha256_text(text):
    """Calculate SHA256 hash of text"""
    return sha256(text.encode()).hexdigest()

# Calculate hashes of your original request and response
request_body_json = '{"model": "...", "messages": [...]}'  # Your request JSON
response_body = '{"id": "...", "choices": [...], ...}'     # Full response JSON

request_hash = sha256_text(request_body_json)
response_hash = sha256_text(response_body)

# Parse the signed hashes
hashed_text = signature_data["text"]
request_hash_server, response_hash_server = hashed_text.split(":")

# Verify they match
assert request_hash == request_hash_server, "Request hash mismatch"
assert response_hash == response_hash_server, "Response hash mismatch"

from eth_account.messages import encode_defunct
from eth_account import Account

# Recover the address that created this signature
message = encode_defunct(text=signature_data["text"])
recovered_address = Account.recover_message(
    message,
    signature=signature_data["signature"]
)

# Verify it matches the claimed signing address
signing_address = signature_data["signing_address"]
assert recovered_address.lower() == signing_address.lower(), \
    "Signature verification failed"

print(f"Signature valid from: {signing_address}")

import secrets

# Generate fresh nonce (prevents replay attacks)
nonce = secrets.token_hex(32)

# Fetch attestation for this specific signing address
attestation_response = requests.get(
    "https://api.redpill.ai/v1/attestation/report",
    params={
        "model": "phala/qwen-2.5-7b-instruct",
        "nonce": nonce,
        "signing_address": signing_address
    },
    headers={"Authorization": f"Bearer {API_KEY}"}
)
attestation_report = attestation_response.json()

# Handle multi-server deployments
if "all_attestations" in attestation_report:
    # Filter for matching signing address
    attestation = next(
        item for item in attestation_report["all_attestations"]
        if item["signing_address"].lower() == signing_address.lower()
    )
else:
    attestation = attestation_report

print(f"Found attestation for: {attestation['signing_address']}")

# Example verification (see attestation guide for full implementation)
def verify_complete_attestation(attestation, nonce, signing_address):
    """Verify all attestation components"""

    # 1. Verify Intel TDX quote
    intel_result = verify_intel_tdx_quote(attestation["intel_quote"])

    # 2. Verify report data binding (CRITICAL)
    report_data = bytes.fromhex(
        intel_result["quote"]["body"]["reportdata"].removeprefix("0x")
    )
    signing_address_bytes = bytes.fromhex(signing_address.removeprefix("0x"))

    assert report_data[:32] == signing_address_bytes.ljust(32, b"\x00"), \
        "Signing address not in TEE report"
    assert report_data[32:64].hex() == nonce, \
        "Nonce mismatch - replay attack"

    # 3. Verify NVIDIA GPU
    verify_nvidia_gpu(attestation, nonce)

    # 4. Verify Docker compose
    verify_docker_compose(attestation, intel_result)

    # 5. Verify Sigstore
    verify_sigstore_provenance(attestation)

    return True

def reconstruct_signed_message(payload):
    message = f"{payload['request_hash']}|{payload['response_hash']}|{payload['timestamp']}|{payload['model']}"
    return hashlib.sha256(message.encode()).hexdigest()

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes

def verify_signature(signature_value, message_hash, public_key):
    public_key.verify(
        bytes.fromhex(signature_value),
        bytes.fromhex(message_hash),
        ec.ECDSA(hashes.SHA256())
    )
    return True

def verify_cert_chain(cert_chain):
    # Verify each certificate against its issuer
    # Ensure final cert is TEE root certificate
    return True