💻 computer science

Lightweight True In-Pixel Encryption with FeFET Enabled Pixel Design for Secure Imaging

This paper presents SecurePix, a compact CMOS-compatible image sensor architecture that utilizes ferroelectric field-effect transistors (FeFETs) to perform lightweight, true in-pixel encryption, effectively securing visual data at the source by drastically reducing neural network recognition accuracy while maintaining low power overhead and enabling authorized recovery via symmetric keys.

Original authors: Md Rahatul Islam Udoy, Diego Ferrer, Wantong Li, Kai Ni, Sumeet Kumar Gupta, Ahmedullah Aziz

Published 2026-04-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Md Rahatul Islam Udoy, Diego Ferrer, Wantong Li, Kai Ni, Sumeet Kumar Gupta, Ahmedullah Aziz

Original paper licensed under CC BY 4.0 (http://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

The Problem: The "Glass House" Camera

Imagine you have a high-tech security camera. In the past, these cameras were like glass houses. They took a picture, and the image traveled out of the camera as a clear, unencrypted stream of data.

If a thief wanted to steal the picture, they didn't need to break into the server room or hack the Wi-Fi. They just had to stand near the wire connecting the camera to the computer and tap into it. Because the data was "in the clear" (unlocked), they could see everything instantly.

Even if you locked the front door (encrypted the Wi-Fi signal), the data was still vulnerable while it was traveling inside the camera's own wiring, before it even left the building.

The Solution: The "Magic Prism" Pixel

The researchers in this paper, led by Md Rahatul Islam Udoy and his team, asked a bold question: "Why wait until the data leaves the camera to lock it? Why not lock it inside every single pixel?"

They created a new type of image sensor called SecurePix.

Think of a standard camera sensor as a grid of millions of tiny buckets (pixels) that catch rain (light). In a normal camera, the water level in each bucket is measured and sent out as a clear number.

In SecurePix, every single bucket has a secret, magical prism attached to it.

The Secret Key: Before the camera takes a picture, the owner programs each bucket with a unique "secret setting" (a key). This is done using a special material called a Ferroelectric Transistor (FeFET). Think of this material like a magnetic switch that remembers its position even when the power is turned off.
The Magic Trick: When light hits the bucket, the water level rises. But because of the secret prism, the water doesn't come out as a clear number. Instead, it comes out as a scrambled, distorted signal.
- If you look at the scrambled signal without the key, it looks like static noise or a messy scribble.
- If you look at it with the key, the prism rotates back, and the original image appears perfectly.

How It Works (The "FeFET" Analogy)

The secret ingredient is a component called an FeFET.

Normal Transistor: Like a light switch that is either ON or OFF.
FeFET (in this paper): Like a dimmer switch with memory. You can set it to 10 different brightness levels, and it will remember that exact level forever, even if you unplug the camera.

The researchers used these "memory dimmers" inside every pixel. They programmed each pixel to a different random setting. When the camera takes a picture, the light hits the sensor, but the "memory dimmer" instantly scrambles the result based on its secret setting.

Why Is This a Big Deal?

The "Glass House" is Now a "Fortress": Even if a hacker taps the wires inside the camera, they only see scrambled noise. They can't see the license plate or the person's face because the scrambling happened before the data ever left the pixel.
It's Tiny and Efficient: Usually, encryption requires a huge, complex computer chip that takes up a lot of space. This new design fits the encryption logic inside the tiny pixel itself. It's like putting a safe inside a postage stamp.
It Stops AI Hackers: Modern hackers use Artificial Intelligence (AI) to guess what a scrambled image might look like. The researchers tested their camera against a powerful AI (ResNet-18).
- Before encryption: The AI recognized images 99% of the time.
- After encryption: The AI's accuracy dropped to about 7% (basically random guessing). The encryption was so good that even a super-smart AI couldn't figure out what the picture was.

How Do You Get the Picture Back?

If the image is scrambled, how do you see it?

The Authorized Receiver: You need the "Master Key." Since the camera remembers the secret settings (the FeFET states), the receiver knows exactly how each pixel was scrambled.
The Lookup Table: The receiver uses a digital "decoder ring" (a lookup table) to reverse the process. It takes the scrambled noise and mathematically unscrambles it, revealing the original, crystal-clear image.

The Bottom Line

This paper introduces a camera that encrypts the image at the very moment it is created, inside the smallest possible unit of the sensor.

Old Way: Take a photo $\rightarrow$ Send it out $\rightarrow$ Lock it at the door. (Hackers can steal it before the door).
SecurePix Way: Lock the photo inside the camera lens before it even leaves the sensor. (Hackers only see noise).

It's a "hardware-level" security system that makes the camera itself the first line of defense, ensuring that your private photos stay private from the moment light hits the sensor.

1. Problem Statement

Traditional image sensors transmit pixel data in clear (unencrypted) form through internal buses and readout lines before any encryption occurs at the system level. This creates a critical vulnerability:

Internal Exposure: Even if the external transmission channel is encrypted, adversaries with physical access can tap internal wiring, column buses, or peripheral circuits to intercept raw analog or lightly processed digital pixel values.
Limitations of Existing Solutions: Current "in-sensor" security methods typically perform encryption in peripheral circuits or column-level processing blocks. This leaves the path from the photodiode to the peripheral block exposed.
Threat Model: Adversaries can use hardware probing, bus tapping, or machine learning (ML) inference to reconstruct scenes from raw data, bypassing downstream encryption entirely.

2. Methodology: SecurePix Architecture

The authors propose SecurePix, a compact CMOS-compatible pixel architecture that performs true in-pixel encryption. The core innovation is embedding the encryption mechanism directly inside the pixel circuit using a Ferroelectric Field-Effect Transistor (FeFET).

Core Component (FeFET): The design utilizes an n-type FeFET with a multidomain ferroelectric capacitor (HfO₂-based). Unlike standard transistors, the FeFET can hold multiple stable, non-volatile polarization states (remnant polarization, $P_R$ ) determined by the programming voltage amplitude (PVA).
Circuit Design:
- The pixel is based on a standard 3-transistor (3T) active pixel structure (Reset, Source Follower, Selector) but integrates an FeFET ( $X_{FE}$ ) in series with the source follower.
- Programming Phase: A row-wise programming protocol is used. A discharge transistor ( $X_{DIS}$ ) pulls the FeFET source to ground, allowing the full programming voltage ( $V_G$ ) to set a specific polarization state. This state acts as the symmetric encryption key for that specific pixel.
- Imaging Phase: During image capture, the photodiode voltage ( $V_{PD}$ ) discharges based on light intensity. The output current ( $I_{OUT}$ ) is determined by the interaction between $V_{PD}$ and the FeFET's programmed conductance.
Encryption Mechanism: The FeFET's programmed state modifies the pixel's analog transfer characteristic. Consequently, the same light intensity produces different encrypted output currents depending on the pixel's unique key. The raw photodiode voltage never leaves the pixel; only the encrypted analog signal is transmitted.
Decryption: Authorized receivers use a Lookup Table (LUT) containing the inverse mapping of the specific FeFET transfer curves (based on the shared symmetric key) to reconstruct the original photodiode voltage and the image.

3. Key Contributions

True In-Pixel Encryption: Unlike prior works that encrypt data after photoconversion, SecurePix encrypts the signal before it leaves the pixel boundary, eliminating exposure on shared readout lines.
Non-Volatile Key Storage: The encryption keys are stored as non-volatile polarization states in the FeFET, requiring no refresh power and persisting across power cycles.
Compact Footprint: The design is highly area-efficient, achieving a pixel pitch of 2.33 × 3.01 μm² in a 45 nm CMOS process, making it viable for high-resolution arrays.
Hardware-Lightweight: The encryption logic is intrinsic to the transistor physics, avoiding the need for complex digital logic or large peripheral circuits within the pixel.

4. Simulation Results & Performance

The authors validated the design using HSPICE simulations with a 45 nm Predictive Technology Model (PTM) and layout verification in Cadence Virtuoso.

Security Metrics:
- Spatial Correlation: Encryption reduced pixel-to-pixel correlation coefficients (horizontal, vertical, diagonal) from >0.88 (in original images) to <0.10 (in encrypted images), effectively removing spatial redundancy.
- ML Resistance: A ResNet-18 neural network trained on unencrypted data achieved:
  - MNIST: 99.29% accuracy (unencrypted) $\rightarrow$ 9.58% (encrypted).
  - CIFAR-10: 91.33% accuracy (unencrypted) $\rightarrow$ 6.98% (encrypted).
  - This indicates the encrypted data is indistinguishable from random noise to modern deep learning models.
Recovery Fidelity: Authorized decryption using LUTs achieved high-quality reconstruction:
- PSNR (Peak Signal-to-Noise Ratio): ~46–47 dB for real-world images (License Plate, Barbara), indicating near-perfect recovery.
Power Efficiency:
- Programming Power-Delay Product (PDP): 17 μW·μs per pixel.
- Sensing PDP: 1.25 μW·μs per pixel.
Key Space: The system supports multiple programming levels (e.g., 8–16 levels), providing 3–4 bits of entropy per pixel, balancing encryption strength with recovery robustness against process variations.

5. Significance

SecurePix represents a paradigm shift in sensor security by moving the "trust boundary" from the system level down to the individual pixel.

Defense-in-Depth: It addresses the most vulnerable point in the imaging pipeline—the raw analog signal generation—preventing attacks that bypass traditional transmission encryption.
Complementarity: The paper argues that SecurePix is not a replacement for existing peripheral encryption but a complementary layer. When combined with downstream security, it creates a robust, end-to-end secure imaging system.
Practicality: By leveraging standard CMOS processes and non-volatile memory devices (FeFETs), the solution offers a scalable, low-overhead hardware security mechanism suitable for next-generation IoT, autonomous vehicles, and surveillance systems where privacy is critical.