💻 computer science

Image Encryption Algorithm Based on Convolutional Neural Networks and Dynamic S-Box Generation

This paper proposes a dynamic image encryption algorithm that leverages Convolutional Neural Networks to generate adaptive, input-dependent S-boxes, thereby enhancing non-linearity and resistance against various cryptographic attacks compared to traditional fixed S-box methods.

Original authors: Ans Ibrahim Mahameed, Fadhil Abbas Fadhil, Maryam Mahdi Alhusseini, Mohammad-Reza Feizi-Derakhshi, Nikolai Safiullin

Published 2026-06-22

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ans Ibrahim Mahameed, Fadhil Abbas Fadhil, Maryam Mahdi Alhusseini, Mohammad-Reza Feizi-Derakhshi, Nikolai Safiullin

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 Big Idea: A Smart Lock That Changes Every Time

Imagine you have a very valuable painting (your image) that you need to send to a friend. Usually, you might put it in a safe box with a standard lock. But if a thief knows how that lock works, they can pick it.

This paper proposes a new kind of "safe box" for digital images. Instead of using a standard, unchanging lock, the authors built a smart lock that reshapes itself every single time you use it. They call this a "Dynamic S-Box."

Here is how they built it and why it works:

1. The Problem with Old Locks

Traditional image encryption is like using a master key that fits many different locks. It's rigid. If a hacker studies the lock, they can figure out the pattern and break it. The paper says these old methods are too predictable because they don't change based on the specific picture they are protecting.

2. The Solution: A "Learning" Lock (The CNN)

The authors used a type of Artificial Intelligence called a Convolutional Neural Network (CNN). Think of a CNN as a super-smart student that has studied thousands of pictures. It knows how to recognize patterns, textures, and details.

How it works: When you want to encrypt a specific image (like a photo of a house or a baboon), the CNN looks at that specific picture.
The Magic: Based on what it sees in that specific photo, the CNN instantly designs a unique, custom "lock" (the S-Box) just for that image.
The Result: If you encrypt a picture of a house, you get one unique lock. If you encrypt a picture of a baboon, the CNN creates a completely different lock. Even if you encrypt the same house again with a tiny change (like a cloud moving), the lock changes entirely.

3. The Encryption Process: A Three-Step Dance

Once the CNN creates this custom lock, the image goes through a three-step dance to scramble it:

Substitution (The Mask): The CNN's custom lock replaces every pixel (dot) in the image with a new, random value. It's like swapping every letter in a secret message with a different letter based on a code that only exists for that specific message.
Permutation (The Shuffle): The image is then shuffled. Imagine taking a deck of cards, looking at the order, and then mixing them up so the "House" pixel is no longer next to the "Roof" pixel. This is done using "chaotic maps" (math that acts like a whirlwind) to ensure the shuffling is totally random.
Diffusion (The Ripple): Finally, the image is mixed with a secret key stream. This is like adding a layer of static noise that spreads across the whole image. If you change just one tiny dot in the original photo, this step ensures that the entire scrambled image looks completely different.

4. Why Is This Better? (The Test Results)

The authors tested their new method on standard pictures (like a baboon, a house, an airplane, and a pepper). Here is what they found:

Unpredictability (Entropy): The scrambled images looked like pure static noise. The data was so random that it was impossible to guess the original picture. The "randomness score" was nearly perfect (close to 8.0).
Sensitivity (NPCR & UACI): If they changed just one pixel in the original photo, the scrambled result changed by more than 99%. It's like changing one letter in a word and having the whole sentence turn into gibberish. This makes it very hard for hackers to guess the secret.
Speed: Despite being smart and complex, the system was fast. It could encrypt and decrypt images in less than 50 milliseconds (faster than a human blink).
Resilience: They tried to "break" the images by cropping them (cutting off parts) or adding noise (static). Even with damage, the original image could still be recovered with good quality, proving the system is tough.

5. The Verdict

The paper concludes that by using a "smart student" (the CNN) to design a unique lock for every single image, they created an encryption system that is:

Harder to crack than old, fixed methods.
Faster than many complex alternatives.
Adaptable, meaning it gets smarter based on the image it is protecting.

In short, they turned image encryption from a "one-size-fits-all" lock into a "custom-made, shape-shifting" vault that changes its rules every time you use it.

Technical Summary: Image Encryption Algorithm Based on Convolutional Neural Networks and Dynamic S-Box Generation

Problem Statement
Traditional image encryption algorithms often struggle with the unique characteristics of image data, such as high data volume, strong spatial correlation, and data clustering. Conventional symmetric key algorithms, like AES, rely on fixed Substitution boxes (S-boxes) to introduce non-linearity and confusion. However, these fixed S-boxes lack adaptability to specific input data, rendering them susceptible to linear and differential cryptanalysis. While recent studies have attempted to improve S-box adaptability using chaotic systems or metaheuristic optimizations, many remain non-data-driven or handcrafted, limiting their flexibility and security against sophisticated attacks. There is a demonstrated need for intelligent, data-driven systems capable of generating secure, image-specific S-boxes.

Methodology
The proposed framework introduces a dynamic image encryption scheme that integrates Convolutional Neural Networks (CNNs) with classical cryptographic principles. The methodology proceeds through five primary stages:

Dataset Preparation and Preprocessing: A dataset of grayscale image patches (e.g., from USC-SIPI, MNIST, or CIFAR-10) is resized to $N \times N$ (e.g., $32 \times 32$ ) and scaled to the range $[0, 1]$ . The goal is to extract statistical and spatial patterns to train the CNN.
CNN-Based S-Box Generation: A CNN is trained to learn an ideal substitution transform.
- Architecture: The network utilizes convolutional layers with ReLU activation to extract image complexity, followed by fully connected layers that map to substitution values (vectors of 16 or 64 elements).
- Output Enforcement: A custom output layer ensures the generated vector forms a valid bijective S-box (a permutation of distinct values in $[0, 255]$ ). This involves discarding replicated values and re-creating them using a hybrid noise injection algorithm driven by CNN weights.
- Loss Function: Training employs a multi-objective loss function: $Loss = -(\alpha \cdot \text{Nonlinearity} + \beta \cdot \text{SAC} + \gamma \cdot \text{BIC} + \delta \cdot \text{Uniformity})$ . This optimizes for resistance to linear cryptanalysis, the Strict Avalanche Criterion (SAC), Bit Independence Criterion (BIC), and value uniformity.
S-Box Evaluation: Generated S-boxes are rigorously tested against cryptographic standards (Nonlinearity, SAC, Differential Uniformity, Bit Independence). Only those exceeding predetermined thresholds are selected for encryption.
Encryption Process: The scheme utilizes a modified Substitution-Permutation Network (SPN) architecture repeated over multiple rounds (typically 3–5):
- Substitution: Pixel values are replaced using the dynamic, CNN-generated S-box.
- Permutation: Pixel positions are rearranged using a permutation vector derived from chaotic maps (e.g., Logistic or Lorenz maps) iterated with a secret key.
- Diffusion: A pixel-wise XOR operation is applied between the permuted image and a key-stream generated by a second CNN-based S-box or a Pseudo-Random Number Generator (PRNG).
Decryption: The process is reversed using the inverse permutation vector and the inverse of the dynamic S-box, ensuring lossless recovery of the original image.

Key Contributions

Adaptive S-Box Generation: The framework generates dynamic S-boxes where the learned features of the specific input image drive the substitution patterns. This enhances non-linearity and confusion compared to static methods.
Hybrid Security Architecture: The integration of deep learning with chaotic nonlinear systems increases randomness and complexity, specifically targeting resistance against differential and statistical attacks.
Performance and Scalability: The algorithm is designed for low weight and scalability, demonstrating the capability for real-time application while securing high-resolution image data.
Comprehensive Evaluation: The study provides a critical examination of the algorithm using standard benchmark images (Baboon, House, Airplane, Pepper) and compares its performance against traditional and recent encryption algorithms.

Experimental Results
The proposed method was evaluated on standard test images using several cryptographic metrics:

Entropy: Values approached the ideal maximum of 8.0 (ranging from 7.9947 to 7.9980), indicating highly unpredictable pixel distributions.
NPCR (Number of Pixels Change Rate): Results exceeded 99.5% (e.g., 99.610% for Baboon), demonstrating high sensitivity to minor input changes and strong resistance to differential attacks.
UACI (Unified Average Changing Intensity): Scores hovered around the ideal 33% (e.g., 33.42%), confirming significant differences between original and encrypted images.
Correlation: Average correlation coefficients between neighboring pixels were near zero (e.g., 0.0058), effectively breaking the natural spatial correlations of the plaintext.
Histogram Uniformity: Encrypted images displayed flat, uniform histograms, destroying visual patterns.
Robustness: The system demonstrated resilience against cropping (up to 20%) and noise attacks (Gaussian and Salt-and-Pepper), maintaining recognizable features with acceptable PSNR and SSIM values.
NIST Statistical Tests: The generated cryptographic keys passed all major NIST statistical tests (Frequency, Runs, Serial, Linear Complexity, etc.) with p-values greater than the significance level of 0.01.
Speed: Encryption and decryption times were under 50 milliseconds for the tested image sizes, confirming computational efficiency.

Significance and Claims
The paper claims that the proposed CNN-based dynamic S-box approach offers a superior balance between performance, complexity, and security compared to traditional fixed S-box methods. By making the substitution mechanism data-driven and image-specific, the system significantly increases resistance to known-plaintext, differential, and statistical attacks. The authors assert that this method resolves traditional trade-offs in image encryption, providing a robust, intelligent solution suitable for secure transmission and storage in modern multimedia and communication systems. The study concludes that the integration of deep learning into cryptographic component design represents a viable path toward more reliable and efficient image encryption systems.