Crypten

Crypten is built directly on PyTorch, allowing machine learning practitioners to use familiar APIs and tensor operations. This design choice means developers can write secure computation code that looks and feels like standard PyTorch, significantly reducing the learning curve.

• CrypTensor objects mirror PyTorch tensors but store data as secret shares
• Supports automatic differentiation for secure training
• Compatible with existing PyTorch model architectures and data loaders
• Minimal code changes required to convert a standard model to an MPC-secure version

Crypten implements secret sharing as its core cryptographic primitive, distributing data across multiple parties so that no single party can reconstruct the original values. All computations—including addition, multiplication, and comparison—are performed on these shares.

• Uses additive secret sharing over a finite field for linear operations
• Implements Beaver triples for efficient secure multiplication
• Supports 2PC and 3PC configurations with semi-honest security
• Includes custom protocols for non-linear functions like ReLU, max pooling, and softmax

Crypten supports both encrypted training and encrypted inference on neural networks. During training, gradients are computed on secret-shared data and never revealed to any single party. During inference, the model weights themselves can be kept private.

• Secure SGD: Stochastic gradient descent operates entirely on encrypted shares
• Supports linear layers, convolutions, batch normalization, and dropout
• Implements secure DReLU (derivative of ReLU) for backpropagation
• Enables private model evaluation where neither the input nor the model is exposed

Crypten uses arithmetic secret sharing over a prime field, where a value x is split into random shares [x]_1 and [x]_2 such that x = [x]_1 + [x]_2 mod p. This enables linear operations to be performed locally without communication.

• Addition: Parties add their local shares independently—zero communication cost
• Multiplication: Requires one round of communication using pre-computed Beaver triples
• Comparison: Implements secure comparison protocols for ReLU and max pooling
• Shares are statistically indistinguishable from random values, providing information-theoretic privacy

Crypten abstracts its cryptographic backend through a provider interface, allowing different MPC protocols to be plugged in without changing the high-level model code. This enables experimentation with various security-performance tradeoffs.

• Default provider uses semi-honest 2PC with arithmetic secret sharing
• TTP provider (Trusted Third Party) for debugging and development without crypto overhead
• Extensible design allows integration of 3PC honest-majority protocols
• Supports switching between providers for different stages of development and deployment

Multiple hospitals collaboratively train a diagnostic model on private patient records without sharing identifiable health data. Each institution holds encrypted shares of its radiological images. Crypten's secure stochastic gradient descent computes weight updates on the combined dataset, allowing the model to learn from diverse patient populations while maintaining HIPAA compliance and data sovereignty. The final model achieves higher accuracy than any single-hospital baseline.

Competing banks jointly train a fraud classifier on transaction graphs without revealing customer account details. Using Crypten's private set intersection and secure aggregation, institutions compute features like shared suspicious account linkages across their combined networks. The collaborative model detects money laundering rings spanning multiple banks that no single institution could identify alone, all while preserving bank secrecy regulations.

A model vendor deploys a proprietary neural network for inference on a client's sensitive data without revealing the model weights. The vendor and client each hold secret shares of the model parameters. Crypten executes MPC-based inference using protocols like secure ReLU evaluation, delivering predictions to the client while the vendor learns nothing about the input data and the client learns nothing about the model architecture or weights.

Research institutions perform secure GWAS across distributed genomic databases to identify genetic variants linked to rare diseases. Each institution secret-shares its genotype and phenotype data. Crypten computes statistical associations using secure matrix multiplication and logistic regression, revealing only the final aggregated p-values. This enables statistically powered studies on conditions requiring large cohorts without pooling sensitive DNA records.

Competing manufacturers benchmark operational efficiency metrics without exposing proprietary production data. Each company secret-shares KPIs like defect rates, throughput, and energy consumption. Crypten computes industry-wide quartiles and averages using secure comparison and division protocols. Participants learn their relative ranking and aggregate benchmarks while individual company data remains cryptographically hidden from rivals.

An advertiser and publisher jointly compute conversion rates without linking individual user identities across domains. The advertiser holds a list of purchasers; the publisher holds a list of ad viewers. Using Crypten's private set intersection cardinality, they learn how many users converted after seeing an ad without revealing which specific users overlap. This enables accurate ROI measurement while respecting GDPR and browser privacy constraints.