Introduction

Chaos-based image encryption algorithms have found widespread application across various industries. However, many existing encryption methods rely on low-dimensional chaotic systems, which compromises security and fails to meet modern cryptographic requirements. To address these limitations, this paper presents a novel image encryption algorithm that combines a six-dimensional (6D) hyperchaotic system with DNA encoding techniques.

The proposed method employs multiple chaotic sequences to perform diffusion and permutation operations on the original image data. These operations are then extended to the DNA level, where different chaotic sequences govern the encoding process. Finally, the various encoded sequences are combined to produce the encrypted image. Experimental results demonstrate that this algorithm achieves image entropy approaching 8, exhibits low pixel correlation, and provides a key space exceeding 2³⁰⁰, offering robust resistance against geometric and truncation attacks.

Background

With advances in digital image processing, image encryption has become critical for information security. Chaotic encryption algorithms have gained attention due to their inherent diffusion and confusion properties. However, traditional low-dimensional chaotic systems suffer from small key spaces and inadequate security margins.

High-dimensional chaotic systems offer superior characteristics for cryptographic applications, including enhanced unpredictability, larger parameter spaces, and more complex dynamics. When combined with DNA encoding—a biological-inspired approach that maps pixel values to DNA base sequences—the resulting encrypsion scheme achieves both mathematical rigor and biological inspiration.

Proposed Algorithm

Key Generation

Six initial values and control parameters are generated to construct the 6D hyperchaotic system key. These parameters are used to initialize the chaotic system, producing six coupled chaotic sequences that serve as pseudo-random number generators.

Image Preprocessing

The original image undergoes binarization and is subsequently divided into 8×8 pixel blocks. This blocking strategy facilitates parallel processing and enables efficient diffusion and permutation operations.

Diffusion Stage

Each pixel block undergoes diffusion using the six chaotic sequences. The diffusion operation modifies pixel values according to the chaotic dynamics, ensuring that changes in one pixel propagate throughout the block.

Permutation Stage

Following diffusion, a different set of chaotic sequences controls the permutation of pixel blocks. This operation rearranges pixel positions while preserving the statistical properties of the image data.

DNA Encoding

The permuted pixel blocks are converted into DNA sequences through binary-to-DNA mapping. The encoding process uses four DNA bases (A, T, C, G) to represent binary values. Additional chaotic sequences then govern the diffusion and permutation of these DNA sequences.

Image Reconstruction

The encoded DNA sequences are transformed back into image format and combined to produce the final encrypted image.

Experimental Results

Image Entropy Analysis

The entropy of encrypted images approaches 8, indicating excellent randomness and minimal information leakage. The entropy value confirms that the encryption algorithm produces outputs with near-perfect statistical distribution.

Pixel Correlation

Encrypted images exhibit extremely low pixel correlation between adjacent pixels, both horizontally and vertically. This property indicates that the algorithm effectively eliminates spatial redundancy in the original image.

Key Space

The algorithm's key space exceeds 2³⁰⁰, providing substantial protection against brute-force attacks. This large key space results from the six-dimensional parameter space combined with the sensitivity of chaotic system initialization.

Robustness Testing

The encrypted images demonstrate strong resilience against geometric attacks (rotation, scaling, cropping) and truncation attacks. Successful decryption after moderate attacks confirms the algorithm's practical applicability in real-world scenarios.

MATLAB Implemantation

function entropy_values = compute_image_entropy(input_image)
    %
    % compute_image_entropy
    % 
    % Calculates Shannon entropy for each color channel of an image.
    % Entropy measures the randomness of pixel intensity distribution.
    %
    
    entropy_values = zeros(1, 3);
    
    function entropy = calculate_channel_entropy(channel_data)
        channel_data = double(channel_data);
        [height, width] = size(channel_data);
        channel_data = channel_data(:)';
        
        histogram = zeros(1, 256);
        for intensity_idx = 1:256
            histogram(intensity_idx) = sum(channel_data == (intensity_idx - 1));
            histogram(intensity_idx) = histogram(intensity_idx) / (height * width);
        end
        
        nonzero_probs = histogram(histogram > 0);
        entropy = -sum(nonzero_probs .* log2(nonzero_probs));
    end
    
    entropy_values(1) = calculate_channel_entropy(input_image(:, :, 1));
    entropy_values(2) = calculate_channel_entropy(input_image(:, :, 2));
    entropy_values(3) = calculate_channel_entropy(input_image(:, :, 3));
end

function encrypted_data = dna_diffusion(image_block, chaos_seq, encoding_rule)
    %
    % dna_diffusion
    %
    % Performs DNA-level diffusion on image data using chaotic sequences.
    % Maps binary image data to DNA sequences and applies chaotic transformation.
    %
    
    binary_stream = de2bi(image_block(:), 8);
    
    dna_mapping = containers.Map('KeyType', 'char', 'ValueType', 'char');
    dna_mapping('00') = 'A';
    dna_mapping('01') = 'T';
    dna_mapping('10') = 'C';
    dna_mapping('11') = 'G';
    
    dna_seq = [];
    for bit_idx = 1:2:size(binary_stream, 2)
        pair = strcat(num2str(binary_stream(bit_idx)), num2str(binary_stream(bit_idx + 1)));
        dna_seq = [dna_seq, dna_mapping(pair)];
    end
    
    dna_table = 'ATCG';
    num_bases = length(dna_seq);
    
    for base_idx = 1:num_bases
        current_base = dna_seq(base_idx);
        base_position = find(dna_table == current_base);
        
        chaos_val = abs(chaos_seq(base_idx));
        shift_amount = mod(floor(chaos_val * 1000), 4);
        
        new_position = mod(base_position - 1 + shift_amount, 4) + 1;
        dna_seq(base_idx) = dna_table(new_position);
    end
    
    encrypted_data = dna_seq;
end

function [cipher_block, key_params] = init_6d_hyperchaos(key_seed)
    %
    % init_6d_hyperchaos
    %
    % Initializes a 6D hyperchaotic system with given seed parameters.
    % Returns chaotic trajectories used for encryption operations.
    %
    
    rng(key_seed, 'twister');
    
    initial_conditions = rand(1, 6) * 10;
    control_params = rand(1, 6) * 0.5 + 15;
    
    system_params = struct();
    system_params.x0 = initial_conditions(1);
    system_params.y0 = initial_conditions(2);
    system_params.z0 = initial_conditions(3);
    system_params.w0 = initial_conditions(4);
    system_params.u0 = initial_conditions(5);
    system_params.v0 = initial_conditions(6);
    
    system_params.a = control_params(1);
    system_params.b = control_params(2);
    system_params.c = control_params(3);
    system_params.d = control_params(4);
    system_params.e = control_params(5);
    system_params.f = control_params(6);
    
    key_params = system_params;
    
    cipher_block = initial_conditions;
end

function [encrypted_img, decryption_keys] = image_encrypt(original_img, master_key)
    %
    % image_encrypt
    %
    % Main encryption function combining 6D hyperchaos and DNA encoding.
    % Returns encrypted image and keys required for decryption.
    %
    
    [rows, cols, channels] = size(original_img);
    encrypted_img = original_img;
    
    block_size = 8;
    num_blocks_row = rows / block_size;
    num_blocks_col = cols / block_size;
    
    key_params = init_6d_hyperchaos(master_key);
    decryption_keys.key_params = key_params;
    decryption_keys.block_order = [];
    
    for channel_idx = 1:channels
        channel_data = original_img(:, :, channel_idx);
        blocks_processed = 0;
        
        for block_row = 1:num_blocks_row
            for block_col = 1:num_blocks_col
                row_start = (block_row - 1) * block_size + 1;
                col_start = (block_col - 1) * block_size + 1;
                
                current_block = channel_data(row_start:row_start + block_size - 1, ...
                                              col_start:col_start + block_size - 1);
                
                block_id = blocks_processed + 1;
                chaos_sequence = generate_chaos_sequence(key_params, block_id, block_size.^2);
                
                modified_block = diffuse_block(current_block, chaos_sequence);
                scrambled_block = permute_block(modified_block, key_params, block_id);
                
                dna_encoded = dna_diffusion(scrambled_block, chaos_sequence, 'standard');
                
                channel_data(row_start:row_start + block_size - 1, ...
                            col_start:col_start + block_size - 1) = dna_encoded;
                
                blocks_processed = blocks_processed + 1;
            end
        end
        
        encrypted_img(:, :, channel_idx) = channel_data;
    end
    
    decryption_keys.final_entropy = compute_image_entropy(encrypted_img);
end

function sequence = generate_chaos_sequence(params, block_id, seq_length)
    sequence = zeros(1, seq_length);
    x = params.x0 + block_id * 0.001;
    y = params.y0 + block_id * 0.002;
    z = params.z0 + block_id * 0.003;
    w = params.w0 + block_id * 0.004;
    u = params.u0 + block_id * 0.005;
    v = params.v0 + block_id * 0.006;
    
    step_size = 0.005;
    for step_idx = 1:seq_length
        dx = y - x + z * u;
        dy = x - y + z * w;
        dz = z + x * y - z * v;
        dw = w + z * x;
        du = u + y * w;
        dv = v + z * u;
        
        x = x + step_size * dx;
        y = y + step_size * dy;
        z = z + step_size * dz;
        w = w + step_size * dw;
        u = u + step_size * du;
        v = v + step_size * dv;
        
        sequence(step_idx) = mod(abs(x) + abs(y) + abs(z) + abs(w) + abs(u) + abs(v), 256) / 256;
    end
end

function diffused = diffuse_block(block_data, chaos_seq)
    [h, w] = size(block_data);
    block_flat = block_data(:);
    
    for elem_idx = 1:length(block_flat)
        chaos_val = floor(chaos_seq(elem_idx) * 256);
        block_flat(elem_idx) = bitxor(uint8(block_flat(elem_idx)), uint8(chaos_val));
    end
    
    diffused = reshape(block_flat, h, w);
end

function permuted = permute_block(block_data, params, block_id)
    [h, w] = size(block_data);
    total_pixels = h * w;
    
    index_sequence = 1:total_pixels;
    perm_seed = params.x0 * 1000 + block_id;
    rng(perm_seed);
    
    perm_order = randperm(total_pixels);
    block_flat = block_data(:);
    block_flat = block_flat(perm_order);
    
    permuted = reshape(block_flat, h, w);
end

Performance Summary