aitbc/docs/development/fhe-service.md

FHE Service

Overview

The Fully Homomorphic Encryption (FHE) Service enables encrypted computation on sensitive machine learning data within the AITBC platform. It allows ML inference to be performed on encrypted data without decryption, maintaining privacy throughout the computation process.

Architecture

FHE Providers

• TenSEAL: Primary provider for rapid prototyping and production use
• Concrete ML: Specialized provider for neural network inference
• Abstract Interface: Extensible provider system for future FHE libraries

Encryption Schemes

• CKKS: Optimized for approximate computations (neural networks)
• BFV: Optimized for exact integer arithmetic
• Concrete: Specialized for neural network operations

TenSEAL Integration

Context Generation

from app.services.fhe_service import FHEService

fhe_service = FHEService()
context = fhe_service.generate_fhe_context(
    scheme="ckks",
    provider="tenseal",
    poly_modulus_degree=8192,
    coeff_mod_bit_sizes=[60, 40, 40, 60]
)

Data Encryption

# Encrypt ML input data
encrypted_input = fhe_service.encrypt_ml_data(
    data=[[1.0, 2.0, 3.0, 4.0]],  # Input features
    context=context
)

Encrypted Inference

# Perform inference on encrypted data
model = {
    "weights": [[0.1, 0.2, 0.3, 0.4]],
    "biases": [0.5]
}

encrypted_result = fhe_service.encrypted_inference(
    model=model,
    encrypted_input=encrypted_input
)

API Integration

FHE Inference Endpoint

POST /v1/ml-zk/fhe/inference
{
  "scheme": "ckks",
  "provider": "tenseal",
  "input_data": [[1.0, 2.0, 3.0, 4.0]],
  "model": {
    "weights": [[0.1, 0.2, 0.3, 0.4]],
    "biases": [0.5]
  }
}

Response:
{
  "fhe_context_id": "ctx_123",
  "encrypted_result": "encrypted_hex_string",
  "result_shape": [1, 1],
  "computation_time_ms": 150
}

Provider Details

TenSEAL Provider

class TenSEALProvider(FHEProvider):
    def generate_context(self, scheme: str, **kwargs) -> FHEContext:
        # CKKS context for neural networks
        context = ts.context(
            ts.SCHEME_TYPE.CKKS,
            poly_modulus_degree=8192,
            coeff_mod_bit_sizes=[60, 40, 40, 60]
        )
        context.global_scale = 2**40
        return FHEContext(...)

    def encrypt(self, data: np.ndarray, context: FHEContext) -> EncryptedData:
        ts_context = ts.context_from(context.public_key)
        encrypted_tensor = ts.ckks_tensor(ts_context, data)
        return EncryptedData(...)

    def encrypted_inference(self, model: Dict, encrypted_input: EncryptedData):
        # Perform encrypted matrix multiplication
        result = encrypted_input.dot(weights) + biases
        return result

Concrete ML Provider

class ConcreteMLProvider(FHEProvider):
    def __init__(self):
        import concrete.numpy as cnp
        self.cnp = cnp

    def generate_context(self, scheme: str, **kwargs) -> FHEContext:
        # Concrete ML context setup
        return FHEContext(scheme="concrete", ...)

    def encrypt(self, data: np.ndarray, context: FHEContext) -> EncryptedData:
        encrypted_circuit = self.cnp.encrypt(data, p=15)
        return EncryptedData(...)

    def encrypted_inference(self, model: Dict, encrypted_input: EncryptedData):
        # Neural network inference with Concrete ML
        return self.cnp.run(encrypted_input, model)

Security Model

Privacy Guarantees

• Data Confidentiality: Input data never decrypted during computation
• Model Protection: Model weights can be encrypted during inference
• Output Privacy: Results remain encrypted until client decryption
• End-to-End Security: No trusted third parties required

Performance Characteristics

• Encryption Time: ~10-100ms per operation
• Inference Time: ~100-500ms (TenSEAL)
• Accuracy: Near-native performance for neural networks
• Scalability: Linear scaling with input size

Use Cases

Private ML Inference

# Client encrypts sensitive medical data
encrypted_health_data = fhe_service.encrypt_ml_data(health_records, context)

# Server performs diagnosis without seeing patient data
encrypted_diagnosis = fhe_service.encrypted_inference(
    model=trained_model,
    encrypted_input=encrypted_health_data
)

# Client decrypts result locally
diagnosis = fhe_service.decrypt(encrypted_diagnosis, private_key)

Federated Learning

• Multiple parties contribute encrypted model updates
• Coordinator aggregates updates without decryption
• Final model remains secure throughout process

Secure Outsourcing

• Cloud providers perform computation on encrypted data
• No access to plaintext data or computation results
• Compliance with privacy regulations (GDPR, HIPAA)

Development Workflow

Testing FHE Operations

def test_fhe_inference():
    # Setup FHE context
    context = fhe_service.generate_fhe_context(scheme="ckks")

    # Test data
    test_input = np.array([[1.0, 2.0, 3.0]])
    test_model = {"weights": [[0.1, 0.2, 0.3]], "biases": [0.1]}

    # Encrypt and compute
    encrypted = fhe_service.encrypt_ml_data(test_input, context)
    result = fhe_service.encrypted_inference(test_model, encrypted)

    # Verify result shape and properties
    assert result.shape == (1, 1)
    assert result.context == context

Performance Benchmarking

def benchmark_fhe_performance():
    import time

    # Benchmark encryption
    start = time.time()
    encrypted = fhe_service.encrypt_ml_data(data, context)
    encryption_time = time.time() - start

    # Benchmark inference
    start = time.time()
    result = fhe_service.encrypted_inference(model, encrypted)
    inference_time = time.time() - start

    return {
        "encryption_ms": encryption_time * 1000,
        "inference_ms": inference_time * 1000,
        "total_ms": (encryption_time + inference_time) * 1000
    }

Deployment Considerations

Resource Requirements

• Memory: 2-8GB RAM per concurrent FHE operation
• CPU: Multi-core support for parallel operations
• Storage: Minimal (contexts cached in memory)

Scaling Strategies

• Horizontal Scaling: Multiple FHE service instances
• Load Balancing: Distribute FHE requests across nodes
• Caching: Reuse FHE contexts for repeated operations

Monitoring

• Latency Tracking: End-to-end FHE operation timing
• Error Rates: FHE operation failure monitoring
• Resource Usage: Memory and CPU utilization metrics

Future Enhancements

• Hardware Acceleration: FHE operations on specialized hardware
• Advanced Schemes: Integration with newer FHE schemes (TFHE, BGV)
• Multi-Party FHE: Secure computation across multiple parties
• Hybrid Approaches: Combine FHE with ZK proofs for optimal privacy-performance balance