💻 computer science

Privacy-Preserving Keystroke Dynamics Authentication Using CKKS Homomorphic Encryption

This paper presents a privacy-preserving keystroke dynamics authentication system implemented using the CKKS homomorphic encryption scheme, which enables secure template matching via encrypted squared Euclidean distance calculations while ensuring biometric vectors remain confidential throughout the process.

Original authors: Nipun Mahaarachchi

Published 2026-07-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nipun Mahaarachchi

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to unlock a secret club, but instead of a key or a password, the bouncer checks how you type. This is called keystroke dynamics, a way of identifying people by their unique typing rhythm—how fast they press keys, how long they hold them down, and the tiny pauses between letters. It's like a digital fingerprint made of time. However, there's a catch: to check if your rhythm matches the club's records, the computer usually has to peek at your typing data in plain sight. If a hacker steals that data, they can't just change it like a password; your typing style is permanent.

To solve this, scientists use a magical trick called homomorphic encryption. Think of this as a locked, opaque box. You can put your data inside, and the computer can do math on the box without ever opening it or seeing what's inside. It's like a chef who can chop, mix, and bake ingredients while they are still sealed inside a glass jar, but the jar is made of lead so no one can see the ingredients, only revealing the final cake at the very end. This paper explores how to use this "locked box" magic specifically for typing rhythms, ensuring that your secret typing style stays hidden even while the computer checks if you are who you say you are.

The Paper's Big Idea: A Secret Typing Test in a Locked Box

The researchers, led by Nipun Mahaarachchi, built a working prototype that combines these two ideas: the unique rhythm of how you type a specific word and the "locked box" math of homomorphic encryption. They didn't invent a new type of magic box; instead, they figured out how to make the box small and light enough to be practical.

Here is how their system works, step-by-step:

1. The "Seven-Step" Dance
Most biometric systems use huge, complex data (like 3D face scans) that are heavy and hard to lock up. This team chose something tiny: the word "password." When you type this eight-letter word, the system doesn't look at the letters themselves. It only watches the time it takes to press each key. Since there are eight keys, there are seven gaps (or intervals) between them. This creates a tiny list of seven numbers.

2. The "Standardized" Rhythm
Everyone types at different speeds. One day you might be rushing; another day, you might be tired. To fix this, the system takes your typing times and "normalizes" them. It's like a dance instructor telling you, "It doesn't matter how fast you dance, just keep the same rhythm as your first practice." The system calculates the average rhythm and the usual variation from your practice sessions, then adjusts your new typing attempt to match that standard.

3. The Locked Box Match
This is where the magic happens.

Enrollment: You type the word a few times to teach the system your rhythm. The system turns this into a "template" (a secret recipe of your rhythm) and locks it inside a cryptographic box using a method called CKKS.
Login: When you try to log in later, the system locks your new typing rhythm in a second box.
The Math: The computer takes both locked boxes and performs a special math operation called "squared Euclidean distance." It subtracts the numbers, squares the results, and adds them up—all while the data remains encrypted inside the boxes. The computer never sees the actual numbers; it only sees the math happening on the locked containers.

4. The Final Reveal
Once the math is done, the computer has a single number: the "distance score." This number tells the system how different your new typing rhythm is from your old one.

If the score is low (meaning you typed very similarly), the box is opened just enough to reveal that small number, and the system says ACCEPT.
If the score is high (meaning the rhythm is totally different, like an impostor), the system says REJECT.

What They Found (and What They Didn't)
The authors tested this with a "proof-of-concept" (a working model to see if the idea is possible). They ran simulations with real typing data and also created fake "impostor" data to see if the system would catch them.

The Result: The system worked. It successfully distinguished between the real user and the fake impostor. The "locked box" math only required 20 operations (7 subtractions, 7 squarings, and 6 additions) because the data list was so short (just 7 numbers).
The Limitation: The paper is very clear that this is not a finished product ready for the whole world yet. It was tested on a single computer with a fixed word and a small number of test runs. The authors admit they haven't proven it works perfectly for thousands of different people or different devices yet. They also note that while the matching happens in the locked box, the raw typing data is still visible in the web browser before it gets locked up.

Why This Matters
The main takeaway is that by choosing a simple, low-dimensional feature (just 7 timing numbers), they made the "locked box" math fast and light. Usually, encrypting complex data is slow and heavy, like trying to carry a heavy safe. By using a tiny vector, they showed that you can have strong privacy without the system dragging its feet.

The authors suggest that this approach could be a stepping stone toward a future where your digital identity is protected by "post-quantum" security (security that even future super-computers can't break), but they emphasize that more testing with many users is needed before this becomes a standard way to log in. For now, it's a successful experiment showing that privacy and speed can coexist in the world of typing-based security.

Technical Summary: Privacy-Preserving Keystroke Dynamics Authentication Using CKKS Homomorphic Encryption

Problem Statement

Biometric authentication offers stronger identity binding than password-based systems but introduces significant privacy risks. Traditional schemes often require decrypting biometric templates on the server to perform matching, creating a "window of exposure" where sensitive feature vectors are visible in server memory, logs, or application logic. While homomorphic encryption (HE) allows computation on encrypted data to mitigate this, it is computationally expensive. Applying HE to high-dimensional biometric representations (e.g., face embeddings or iris templates) is often impractical due to the sheer volume of arithmetic operations required on ciphertexts.

Methodology

The paper proposes a design-first approach that combines Keystroke Dynamics with the CKKS (Cheon-Kim-Kim-Song) homomorphic encryption scheme. The core strategy is to utilize a low-dimensional behavioral biometric representation to minimize the computational overhead of encrypted matching.

System Architecture

The system operates in two phases: Enrollment and Authentication, implemented via a browser-based interface (JavaScript) and a Python/Flask backend using OpenFHE and NumPy.

Feature Extraction:
- The user types a fixed passphrase ("password").
- The system captures eight keydown timestamps ( $t_1, \dots, t_8$ ).
- It extracts seven press-to-press timing intervals ( $PP_i = t_{i+1} - t_i$ ), resulting in a 7-dimensional feature vector.
Standardization and Template Construction:
- To address variability in typing speed, raw timing values are standardized using enrollment statistics (mean $\mu_i$ and standard deviation $\sigma_i$ ).
- The enrollment template ( $X$ ) is generated by averaging $m=5$ normalized enrollment samples.
- The login vector ( $Y$ ) is normalized using the same enrollment parameters.
Encrypted Matching (CKKS):
- Both the template $X$ and the login vector $Y$ are encrypted using the CKKS public key.
- The system computes the Squared Euclidean Distance homomorphically:
  $Enc(D) = \sum_{i=1}^{7} (Enc(X_i) - Enc(Y_i))^2$
- This operation requires only subtraction, squaring (multiplication), and summation on ciphertexts.
- The final scalar distance score $D$ is decrypted only at the very end.
Decision Logic:
- A threshold $T$ is established based on the mean and standard deviation of genuine enrollment distances ( $T = \mu_D + 3\sigma_D$ ).
- If $D < T$ , the system returns ACCEPT; otherwise, REJECT.

Key Contributions

End-to-End Encrypted Workflow: The paper demonstrates a complete web-based authentication flow where biometric matching occurs entirely within the encrypted domain, preventing the server from ever seeing the raw or normalized feature vectors during the comparison process.
Design-First Optimization: Instead of applying HE to complex, high-dimensional data, the authors intentionally selected keystroke dynamics to generate a compact 7-dimensional vector. This design choice significantly reduces the multiplicative depth and operation count required for homomorphic evaluation.
Implementation with OpenFHE: The work provides a practical implementation using the OpenFHE library, detailing the setup of the cryptographic context, key generation, and the specific sequence of homomorphic operations (subtraction, squaring, summation) needed for distance calculation.

Experimental Results

The system was evaluated as a controlled proof-of-concept rather than a full biometric benchmark.

Functionality: The system successfully distinguished between genuine users (scores below the threshold) and simulated impostors (scores significantly above the threshold).
Computational Efficiency: By limiting the feature vector to dimension $d=7$ , the system required only 20 homomorphic operations (7 subtractions, 7 squarings, 6 additions). The authors note that a 128-dimensional vector would require over 380 operations, highlighting the efficiency gains of the low-dimensional approach.
Resource Usage: Runtime and resource monitoring (CPU, memory) on an Ubuntu virtual machine indicated that the Flask/OpenFHE application remained practical for this specific workflow.

Significance and Claims

The paper modestly claims that its primary contribution is not a new cryptographic primitive, but rather the successful embedding of a low-dimensional behavioral biometric representation into a CKKS encrypted-domain matching workflow.

The authors emphasize that:

Privacy is Restricted to the Matching Process: The system ensures that biometric vectors remain encrypted during the matching phase, reducing exposure compared to systems that decrypt templates for comparison.
Feasibility of Lightweight HE: The results validate that lightweight encrypted-domain biometric matching is viable when the feature design is optimized to minimize computational complexity.
Scope Limitations: The authors explicitly state that this is not a production-ready system. It lacks formal biometric accuracy validation (FAR, FRR, EER), multi-user testing, and robust key management (e.g., Hardware Security Modules). The current implementation serves as a basis for future lightweight, privacy-preserving, and post-quantum-oriented authentication systems.