Homomorphic Encryption in Python — Core Concepts

What makes encryption “homomorphic”

Standard encryption scrambles data to protect it during storage or transit. Once you need to actually use the data, you decrypt it first. Homomorphic encryption breaks this pattern: mathematical operations performed on ciphertext produce results that, when decrypted, match operations performed on the plaintext.

The term “homomorphic” comes from algebra — it means a structure-preserving map. An encryption scheme is additively homomorphic if encrypting two numbers and adding the ciphertexts gives you an encryption of their sum. It’s multiplicatively homomorphic if the same applies to multiplication.

The three tiers

Partially homomorphic encryption (PHE) supports one operation — either addition or multiplication — unlimited times. RSA is naturally multiplicatively homomorphic. The Paillier cryptosystem supports addition. PHE schemes are fast and have been used in production for decades.

Somewhat homomorphic encryption (SHE) supports both addition and multiplication, but only a limited number of times. Each operation introduces noise into the ciphertext, and after too many operations the noise overwhelms the signal, making decryption fail.

Fully homomorphic encryption (FHE) supports arbitrary computations — any function you can express as a circuit. FHE schemes use a technique called bootstrapping to periodically reduce noise, enabling unlimited operations. The cost is dramatic: bootstrapping is computationally expensive.

Key schemes used in Python

BFV (Brakerski/Fan-Vercauteren) operates on integers. You define a plaintext modulus that determines the range of values you can work with. BFV is efficient for exact arithmetic — counting, voting, integer statistics.

CKKS (Cheon-Kim-Kim-Song) operates on approximate real numbers. Instead of exact results, CKKS gives results within a controlled precision, similar to floating-point arithmetic. This makes it ideal for machine learning and scientific computation where small rounding errors are acceptable.

BGV (Brakerki-Gentry-Vaikuntanathan) is similar to BFV but manages noise differently. It’s often more efficient for deep circuits with many sequential multiplications.

How it works in practice

A typical workflow has three roles: the key holder who generates keys and can decrypt, the data owner who encrypts data (sometimes the same as the key holder), and the compute provider who operates on ciphertexts without access to the secret key.

The key holder generates a public key (for encryption), a secret key (for decryption), and often evaluation keys (relinearization and Galois keys that let the compute provider perform rotations and multiplications without the secret key).

The data owner encrypts inputs using the public key and sends ciphertexts to the compute provider. The provider performs additions, multiplications, and rotations on ciphertexts, then returns results. The key holder decrypts with the secret key.

Noise budget — the hidden constraint

Every ciphertext carries a “noise budget.” Additions consume almost no budget. Multiplications consume significant budget. When the budget hits zero, decryption produces garbage.

The initial noise budget depends on encryption parameters: polynomial modulus degree (usually 4096, 8192, or 16384) and coefficient modulus size. Larger parameters give more budget but make operations slower and ciphertexts larger.

Choosing parameters means balancing depth of computation against performance. Libraries typically expose parameter selection helpers — you specify the multiplicative depth you need, and they pick appropriate sizes.

Common misconception

“Homomorphic encryption can replace all other privacy techniques.” In practice, FHE is still 1,000x to 1,000,000x slower than plaintext computation depending on the operation. For many use cases, combining simpler techniques — like differential privacy or secure multiparty computation — is more practical. Homomorphic encryption shines specifically when a single untrusted party must compute on encrypted data from a single source.

Real-world adoption

Microsoft’s SEAL library (with Python bindings) powers privacy-preserving analytics internally. Google uses FHE for private set intersection in Chrome. Several healthcare startups use CKKS-based encrypted machine learning to analyze patient data on cloud infrastructure without exposing records.

The one thing to remember: Homomorphic encryption lets you choose how many operations to perform on encrypted data — from simple addition (fast, mature) to arbitrary computation (powerful but slow) — with the scheme choice determining the tradeoff.