Homomorphic Encryption

Encryption usually forces a hard choice. You can store data safely in the cloud, but the moment you want to do something with it — add up a column, run a search, train a model — you have to decrypt it first. For a fraction of a second, your private data sits in the clear on a machine you do not control.

Homomorphic encryption dissolves that choice. It lets an untrusted server take your locked numbers, perform real arithmetic on them, and hand back a locked result — one that, when you unlock it, is exactly the answer you wanted. The server never sees a single plaintext value, never holds the key, and still does the work.

For thirty years this was a dream. In 2009, Craig Gentry proved it was real with the first fully homomorphic encryption (FHE) scheme. The idea sounds impossible, so the best way to believe it is to watch it happen.

Pick two numbers and a secret key that never leaves your side. Encrypt each number, then send only the scrambled ciphertexts to an "untrusted server." The server adds the two ciphertexts together — it has no key, so to it they are just noise — and returns a single scrambled result. Decrypt it, and out comes the exact sum.

<p class="hint">{{hint}}</p>
<div class="inputs">
  <label>a <input id="a" type="number" value="7"></label>
  <label>b <input id="b" type="number" value="35"></label>
</div>
<div class="btns">
  <button id="enc" type="button">{{btn_enc}}</button>
  <button id="add" type="button" disabled>{{btn_add}}</button>
  <button id="dec" type="button" disabled>{{btn_dec}}</button>
  <button id="reset" type="button" class="ghost">{{btn_reset}}</button>
</div>
<div class="panels">
  <div class="panel you">
    <div class="ptitle">{{panel_you_title}} <span>{{panel_you_sub}}</span></div>
    <div id="you" class="rows"></div>
  </div>
  <div class="panel srv">
    <div class="ptitle">{{panel_srv_title}} <span>{{panel_srv_sub}}</span></div>
    <div id="srv" class="rows"></div>
  </div>
</div>
<div class="status" id="status">{{status_initial}}</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.inputs { display: flex; gap: 1rem; margin: .4rem 0 .7rem; }
.inputs label { font-weight: 600; font-size: .95rem; display: flex; align-items: center; gap: .4rem; }
.inputs input { width: 70px; font: 600 15px ui-monospace, monospace; padding: .3rem .4rem;
                border: 1px solid #adb1b8; border-radius: 6px; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-bottom: .8rem; }
button { font: 600 13px system-ui, sans-serif; padding: .45rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button:disabled { opacity: .4; cursor: not-allowed; }
button.ghost { background: #fff; color: #1d3557; }
.panels { display: grid; grid-template-columns: 1fr 1fr; gap: .7rem; }
.panel { border: 1px solid #cdd9e3; border-radius: 10px; padding: .6rem .7rem; min-height: 96px; }
.panel.you { background: #eef5ec; border-color: #bcd6b6; }
.panel.srv { background: #f1f1f4; border-color: #cdd0d6; }
.ptitle { font-weight: 700; font-size: .82rem; margin-bottom: .4rem; color: #1d3557; }
.ptitle span { font-weight: 400; color: #667; }
.rows { font: 600 13px ui-monospace, monospace; line-height: 1.55; word-break: break-all; }
.rows .lbl { color: #555; font-weight: 400; }
.rows .ct { color: #8a4b00; }
.rows .pt { color: #0a7d33; }
.status { font-size: .95rem; font-weight: 600; margin: .7rem 0 0; min-height: 1.3em; color: #1d3557; }
.status.ok { color: #0a7d33; }
@media (max-width: 460px) { .panels { grid-template-columns: 1fr; } }

// Code not found

Watch the Server view: it sees only large meaningless numbers, yet its blind addition lines up perfectly with your plaintext sum once you decrypt. This works because the scheme is additively homomorphic — adding ciphertexts mirrors adding the secrets inside them. Full schemes add multiplication too, and with both operations you can evaluate any program on encrypted data. The catch is cost, which is where the complexity comes in.

So how hard is it, really? The status here is unusual: fully homomorphic encryption is solved — it exists and is proven correct — yet making it fast is the open engineering frontier.

• It is achievable. In 2009, Craig Gentry built the first fully homomorphic encryption (FHE) scheme in his PhD thesis, settling a question open since 1978. Both encrypted addition and multiplication are now possible.
• The price is overhead. Each ciphertext carries a bit of random noise that grows with every operation. Multiply too many times and the noise drowns the answer. Gentry's breakthrough was bootstrapping — homomorphically decrypting and re-encrypting to refresh the noise — which is correct but costly.
• The security rests on lattices. FHE schemes are built on the Learning With Errors problem and related lattice problems, which are believed hard for classical and quantum computers — unlike the factoring that protects RSA.
• The frontier is speed. Modern libraries have cut the slowdown from billions of times to thousands, but evaluating a heavy computation on encrypted data is still far slower than on plaintext.

The punchline: homomorphic encryption is a rare case where the impossible-sounding part is settled, and the entire remaining battle is shrinking the constant factor enough to make it practical.

"Let someone else compute on my data without trusting them with it" describes a surprising amount of the modern world:

• Private cloud computing: hand a provider your encrypted spreadsheet, get back encrypted analytics, and never expose the raw rows.
• Encrypted machine learning: run a trained model over a patient's encrypted scan or a bank's encrypted transactions, returning a prediction nobody but the owner can read.
• Medical and genomic research: hospitals can jointly compute statistics over encrypted records without pooling sensitive data.
• Private search and querying: ask a database a question without the server learning what you asked or what it returned.

Each of these used to demand a trusted middleman. Homomorphic encryption replaces trust with math, and pairs naturally with ideas like zero-knowledge proofs for a future where privacy is the default, not a favor.

Homomorphic encryption answers a question that sounds like a paradox: can a machine do useful work on data it is forbidden to understand? For three decades the honest answer was "we don't know." Since 2009, the answer is yes — provably, fully, for any computation.

What remains is not a question of possibility but of price. Every year the slowdown shrinks, and the day encrypted computation becomes routine is the day the cloud stops being a place you must trust. The hardest part was believing it could exist at all — and that part, against all intuition, is already done.