Security & Cryptography MATLAB Projects (20+ Ideas with Complete Code)

% 1. Generate Synthetic SPECT Phantom & Radon Sinogram
phantom_img = phantom('Modified Shepp-Logan', 256);
theta = 0:1:179;
[R, xp] = radon(phantom_img, theta);

% 2. Pipelined Filtered Backprojection with Ram-Lak Filter
tic;
recon_img = iradon(R, theta, 'Ram-Lak', 'Linear', 1, 256);
t_recon = toc;

% 3. Quantitative Reconstruction Fidelity Analysis
recon_psnr = psnr(recon_img, phantom_img);
recon_ssim = ssim(recon_img, phantom_img);
fprintf('Reconstruction Completed in %.4f s | PSNR: %.2f dB | SSIM: %.4f\n', t_recon, recon_psnr, recon_ssim);

figure;
subplot(1,3,1); imshow(phantom_img, []); title('Original SPECT Phantom');
subplot(1,3,2); imshow(R, [], 'XData', theta, 'YData', xp); title('Radon Sinogram'); xlabel('\theta (degrees)');
subplot(1,3,3); imshow(recon_img, []); title(sprintf('Reconstructed (PSNR: %.1fdB)', recon_psnr));

% 1. Logistic-Chebyshev Chaotic Map Key Stream Generation
N_sub = 64; N_sym = 1000;
x0 = 0.723456789123; r = 3.99999;
chaos_seq = zeros(1, N_sub * N_sym);
x = x0;
for i = 1:length(chaos_seq)
    x = r * x * (1 - x);
    chaos_seq(i) = x;
end
[~, perm_idx] = sort(chaos_seq(1:N_sub));

% 2. QAM Modulation & Subcarrier Scrambling
data_bits = randi([0 1], N_sub * N_sym * 4, 1);
tx_symbols = qammod(data_bits, 16, 'InputType', 'bit', 'UnitAveragePower', true);
tx_grid = reshape(tx_symbols, N_sub, N_sym);
tx_scrambled = tx_grid(perm_idx, :); % Scrambled Subcarrier Mapping

% 3. OFDM IFFT & AWGN Channel Transmission
ofdm_tx = ifft(tx_scrambled, N_sub, 1);
rx_signal = awgn(ofdm_tx, 18, 'measured');

% 4. Receiver Decryption (Authorized Bob vs Eve with Wrong Key)
rx_ofdm = fft(rx_signal, N_sub, 1);
[~, inv_perm] = sort(perm_idx);
rx_bob = rx_ofdm(inv_perm, :);
bob_bits = qamdemod(rx_bob(:), 16, 'OutputType', 'bit', 'UnitAveragePower', true);
[~, ber_bob] = biterr(data_bits, bob_bits);
fprintf('Authorized Receiver BER: %.6e\n', ber_bob);

% 1. Define 4-CSK Constellation Points in CIE 1931 Color Coordinates
xy_csk = [0.65 0.33; 0.20 0.70; 0.15 0.06; 0.33 0.33]; % Red, Green, Blue, White
bits_user1 = randi([0 1], 100, 1);

% 2. Orthogonal Walsh-Hadamard Spreading Code (Security Key)
H = hadamard(8);
code_user1 = H(2, :); % Orthogonal channel code

% 3. Spread Spectrum CSK Modulation
spread_signal = kron(2*bits_user1 - 1, code_user1');
rx_noisy = awgn(spread_signal, 12, 'measured');

% 4. Despreading and Correlation Detection
despread = reshape(rx_noisy, 8, [])' * code_user1' / 8;
recovered_bits = despread > 0;
ber = mean(bits_user1 ~= recovered_bits);
fprintf('Multi-User VLC CSK-CDMA BER: %.4f\n', ber);

% 1. Priority Parameter & Hierarchical 4/16-QAM Constellation
alpha = 2.5; % Distance ratio between basic and secret streams
N = 10000;
bits_basic = randi([0 1], N, 2);   % Public basic data
bits_secret = randi([0 1], N, 2);  % Encrypted high-security data

% 2. Generate Hierarchical Constellation Points
sym_basic = (2*bits_basic(:,1)-1)*alpha + 1i*(2*bits_basic(:,2)-1)*alpha;
sym_secret = (2*bits_secret(:,1)-1) + 1i*(2*bits_secret(:,2)-1);
tx_hierarchical = (sym_basic + sym_secret) / sqrt(2*(alpha^2 + 1));

% 3. Pass Through AWGN Channel
snr_db = 15;
rx_signal = awgn(tx_hierarchical, snr_db, 'measured');
scatterplot(rx_signal); title('Hierarchical 4/16-QAM Constellation');

% 1. Define Multi-Objective Optimization (Cost Minimization + Load Flattening for Privacy)
nvars = 24; % 24-hour scheduling horizon
tou_price = [0.12*ones(1,6), 0.28*ones(1,10), 0.45*ones(1,6), 0.15*ones(1,2)]; % Time of Use tariff

% Objective 1: Electricity Cost | Objective 2: Variance in Power (Privacy Protection)
fitness_fn = @(P) [sum(P .* tou_price), var(P)];

lb = zeros(1, 24); ub = 5 * ones(1, 24); % Appliance kW bounds
Aeq = ones(1, 24); beq = 30;              % Total daily energy requirement: 30 kWh

% 2. Solve Pareto Front with Multi-Objective Genetic Algorithm
options = optimoptions('gamultiobj', 'Display', 'off', 'PopulationSize', 60);
[x_pareto, fval_pareto] = gamultiobj(fitness_fn, nvars, [], [], Aeq, beq, lb, ub, options);

figure; plot(fval_pareto(:,1), fval_pareto(:,2), 'bo', 'MarkerFaceColor', 'b');
xlabel('Daily Cost ($)'); ylabel('Power Profile Variance (NILM Leakage)');
title('Smart Grid Privacy-Cost Pareto Trade-Off Front'); grid on;

% 1. Fractional-Order Chen Chaotic Attractor Simulation
a = 35; b = 3; c = 28; % True System Parameters
chen_sys = @(t, y) [a*(y(2) - y(1)); (c - a)*y(1) - y(1)*y(3) + c*y(2); y(1)*y(2) - b*y(3)];

tspan = 0:0.01:25;
[t, Y_true] = ode45(chen_sys, tspan, [0.1, 0.2, 0.3]);

% 2. Plot 3D Chaotic Attractor (Phase Space)
figure;
plot3(Y_true(:,1), Y_true(:,2), Y_true(:,3), 'Color', [0 0.4 0.8], 'LineWidth', 0.8);
grid on; xlabel('x(t)'); ylabel('y(t)'); zlabel('z(t)');
title('Fractional-Order Chen Chaotic Phase Space Trajectory');

% 1. Define Floating-Point & Fixed-Point Numeric Types
float_data = sin(2*pi*(0:127)/32) + 0.1*randn(1, 128);
T_fixed16 = numerictype(1, 16, 14); % Signed 16-bit word, 14-bit fraction
T_fixed8  = numerictype(1, 8, 6);   % Signed 8-bit word, 6-bit fraction

% 2. Quantization and Fixed-Point Representation
fix_data16 = fi(float_data, T_fixed16);
fix_data8  = fi(float_data, T_fixed8);

% 3. Compute Quantization Error & SQNR
err16 = double(fix_data16) - float_data;
sqnr16 = snr(float_data, err16);
fprintf('16-bit Fixed-Point SQNR: %.2f dB\n', sqnr16);

% 1. Smart Meter 24h Load Profiles (100 Households)
N_homes = 100;
true_loads = 1.5 + 0.8*randn(N_homes, 24); % Base load in kW
true_aggregate = sum(true_loads, 1);

% 2. Add Laplace Differential Privacy Noise (Sensitivity Delta S = 5 kW)
epsilon = 0.5; % Privacy budget parameter
delta_S = 5.0; scale = delta_S / epsilon;
u = rand(1, 24) - 0.5;
laplace_noise = -scale * sign(u) .* log(1 - 2*abs(u));
priv_aggregate = true_aggregate + laplace_noise;

% 3. Compute Aggregation Error
mape = mean(abs(priv_aggregate - true_aggregate) ./ true_aggregate) * 100;
fprintf('Privacy Budget epsilon = %.2f | Utility MAPE: %.2f%%\n', epsilon, mape);

% 1. Split-Step Fourier Method Parameters for Non-Linear Fiber
N_pts = 1024; dt = 1e-14; t = (-N_pts/2:N_pts/2-1)*dt;
P0 = 5000; T0 = 50e-15; gamma = 0.01; beta2 = -20e-27;

% 2. Initial Hyperbolic Secant Soliton Pulse
u0 = sqrt(P0) * sech(t / T0);
u_f = fftshift(fft(u0));

% 3. Dispersion Step in Frequency Domain
w = 2*pi*(-N_pts/2:N_pts/2-1)/(N_pts*dt);
dispersion_op = exp(-1i * 0.5 * beta2 * w.^2 * 0.001);
u_disp = ifft(ifftshift(u_f .* dispersion_op));

% 4. Non-Linear Self-Phase Modulation Step
u_out = u_disp .* exp(1i * gamma * abs(u_disp).^2 * 0.001);
figure; plot(t*1e15, abs(u0).^2, 'b--', t*1e15, abs(u_out).^2, 'r', 'LineWidth', 1.5);
legend('Input Pump Pulse', 'Broadened Supercontinuum Pulse'); xlabel('Time (fs)'); grid on;

% 1. Synthesize Composite Overlapping RF Signals
fs = 1e6; t = 0:1/fs:0.005;
s1 = chirp(t, 50e3, 0.005, 150e3);     % Target LPI radar pulse
s2 = 0.8 * cos(2*pi*300e3*t);          % Co-channel continuous wave
composite_rx = awgn(s1 + s2, 5, 'measured');

% 2. 4-Level Wavelet Decomposition (Daubechies 'db4')
[C, L] = wavedec(composite_rx, 4, 'db4');
d1 = wrcoef('d', C, L, 'db4', 1); % High-freq band
d2 = wrcoef('d', C, L, 'db4', 2); % Mid-high band
a4 = wrcoef('a', C, L, 'db4', 4); % Low-freq approximation

figure;
subplot(3,1,1); plot(t*1e3, composite_rx); title('Noisy Overlapping RF Input');
subplot(3,1,2); plot(t*1e3, d2); title('Extracted Intermediate Wavelet Channel (D2)');
subplot(3,1,3); plot(t*1e3, a4); title('Extracted Low-Frequency Baseband (A4)'); xlabel('Time (ms)');

% 1. Synthesize/Load Voice Feature Vectors (13-element MFCC)
fs = 16000;
t1 = (0:4000)/fs; s_enrolled = sin(2*pi*220*t1) .* exp(-2*t1);
t2 = (0:4500)/fs; s_test     = sin(2*pi*225*t2) .* exp(-1.8*t2);

% 2. Extract MFCC Features
coeffs_enrolled = mfcc(s_enrolled', fs, 'LogEnergy', 'Ignore');
coeffs_test     = mfcc(s_test', fs, 'LogEnergy', 'Ignore');

% 3. Compute DTW Alignment Distance
[dist, ix, iy] = dtw(coeffs_enrolled, coeffs_test);
threshold = 120.0; % Calibration threshold
if dist < threshold
    disp(['Access Granted: Speaker Verified (DTW Distance = ', num2str(dist), ')']);
else
    disp(['Access Denied: Impostor Detected (DTW Distance = ', num2str(dist), ')']);
end

% 1. Short-Time Energy (STE) and Zero-Crossing Rate (ZCR) for Voice Activity Detection
fs = 8000; t = 0:1/fs:1;
audio_cmd = [zeros(1,1000), 0.8*sin(2*pi*300*(0:1/fs:0.5)), zeros(1,2000)]; % Simulated command

frame_len = 160; frame_step = 80;
frames = buffer(audio_cmd, frame_len, frame_len - frame_step, 'nodelay');

% 2. Compute Frame Energy & ZCR
ste = sum(frames.^2, 1);
zcr = sum(abs(diff(sign(frames))), 1) / (2 * frame_len);

% 3. Adaptive Thresholding to Find Word Endpoints
speech_frames = find(ste > 0.05 * max(ste) & zcr < 0.3);
start_idx = speech_frames(1) * frame_step;
end_idx = speech_frames(end) * frame_step;
fprintf('Detected Voice Command Extent: %d to %d samples\n', start_idx, end_idx);

% 1. Generate Voice Envelope Templates
t = 0:0.001:1;
enrolled_template = sin(2*pi*5*t) .* exp(-t);
test_sample_auth  = sin(2*pi*5*t) .* exp(-t) + 0.05*randn(size(t));
test_sample_impost = sin(2*pi*8*t) .* exp(-1.5*t);

% 2. Compute Normalized Cross-Correlation Peak
r_auth = max(xcorr(enrolled_template, test_sample_auth, 'coeff'));
r_impost = max(xcorr(enrolled_template, test_sample_impost, 'coeff'));

fprintf('Enrolled Match Score: %.4f (Verified)\n', r_auth);
fprintf('Impostor Match Score: %.4f (Rejected)\n', r_impost);

% 1. Optical Channel Parameters for Alice, Bob, and Eve
snr_bob_db = 10:2:30;
snr_eve_db = 12; % Fixed eavesdropper channel quality

snr_bob = 10.^(snr_bob_db / 10);
snr_eve = 10.^(snr_eve_db / 10);

% 2. Secrecy Capacity Calculation: Cs = max(0, C_bob - C_eve)
c_bob = 0.5 * log2(1 + (exp(1)/(2*pi)) * snr_bob);
c_eve = 0.5 * log2(1 + (exp(1)/(2*pi)) * snr_eve);
c_secrecy = max(0, c_bob - c_eve);

figure; plot(snr_bob_db, c_secrecy, 'b-o', 'LineWidth', 2);
grid on; xlabel('Bob SNR (dB)'); ylabel('Secrecy Capacity (bits/channel use)');
title('IM-DD Optical Wiretap Channel Secrecy Capacity');

% 1. Load Plaintext Image & Setup Arnold Cat Map Parameters
img_plain = imread('cameraman.tif');
[N, ~] = size(img_plain);
a = 3; b = 5; num_iter = 10;

% 2. Arnold Cat Map Permutation
img_scrambled = img_plain;
for k = 1:num_iter
    temp = img_scrambled;
    for x = 1:N
        for y = 1:N
            nx = mod((x-1) + a*(y-1), N) + 1;
            ny = mod(b*(x-1) + (a*b+1)*(y-1), N) + 1;
            img_scrambled(nx, ny) = temp(x, y);
        end
    end
end

% 3. Chaotic Diffusion via Logistic Map
x = 0.54321; r = 3.9999;
chaos_mask = zeros(N, N, 'uint8');
for i = 1:(N*N)
    x = r * x * (1 - x);
    chaos_mask(i) = uint8(mod(floor(x * 1e7), 256));
end
img_cipher = bitxor(img_scrambled, chaos_mask);
fprintf('Cipher Entropy: %.4f bits\n', entropy(img_cipher));

% 1. 2D DWT Decomposition of Cover Image
cover = im2double(imread('cameraman.tif'));
[LL, LH, HL, HH] = dwt2(cover, 'haar');

% 2. SVD of High-Frequency Subband (HH) & Secret Payload
[U_c, S_c, V_c] = svd(HH);
secret_logo = im2double(imresize(imread('rice.png'), size(S_c)));
alpha = 0.05; % Embedding strength factor

% 3. Embed & Reconstruct Stego Image
S_mod = S_c + alpha * secret_logo;
[U_s, S_s, V_s] = svd(S_mod);
HH_stego = U_c * S_s * V_c';
stego_img = idwt2(LL, LH, HL, HH_stego, 'haar');

fprintf('Stego Image PSNR: %.2f dB | SSIM: %.4f\n', psnr(stego_img, cover), ssim(stego_img, cover));

% 1. Preprocess & Skeletonize Fingerprint Image
fp_raw = imread('coins.png'); % Example ridge image
fp_bin = imbinarize(fp_raw);
fp_thin = bwmorph(~fp_bin, 'thin', Inf);

% 2. Minutiae Detection (Cross Number Analysis on 3x3 Neighborhood)
[M, N] = size(fp_thin);
endings = []; bifurcations = [];
for r = 2:M-1
    for c = 2:N-1
        if fp_thin(r,c) == 1
            neighbors = [fp_thin(r-1,c-1), fp_thin(r-1,c), fp_thin(r-1,c+1), ...
                         fp_thin(r,c+1), fp_thin(r+1,c+1), fp_thin(r+1,c), ...
                         fp_thin(r+1,c-1), fp_thin(r,c-1), fp_thin(r-1,c-1)];
            cn = 0.5 * sum(abs(diff(neighbors)));
            if cn == 1, endings = [endings; r, c]; end
            if cn == 3, bifurcations = [bifurcations; r, c]; end
        end
    end
end
fprintf('Detected %d Ridge Endings & %d Bifurcations\n', size(endings,1), size(bifurcations,1));

% 1. Construct 1D CNN-LSTM Deep Intrusion Detection Architecture
numFeatures = 41; numClasses = 5; % Normal, DoS, Probe, R2L, U2R

layers = [
    sequenceInputLayer(numFeatures, 'Name', 'input')
    convolution1dLayer(3, 32, 'Padding', 'same', 'Name', 'conv1')
    batchNormalizationLayer('Name', 'bn1')
    reluLayer('Name', 'relu1')
    lstmLayer(64, 'OutputMode', 'last', 'Name', 'lstm')
    dropoutLayer(0.3, 'Name', 'drop')
    fullyConnectedLayer(numClasses, 'Name', 'fc')
    softmaxLayer('Name', 'softmax')
    classificationLayer('Name', 'output')
];

% 2. Training Hyperparameters
options = trainingOptions('adam', ...
    'MaxEpochs', 20, ...
    'MiniBatchSize', 128, ...
    'InitialLearnRate', 0.001, ...
    'Plots', 'training-progress', ...
    'Verbose', false);

% 1. Alice Prepares Random Bits & Quantum Bases (0: Rectilinear +, 1: Diagonal x)
N_qubits = 10000;
alice_bits  = randi([0 1], 1, N_qubits);
alice_bases = randi([0 1], 1, N_qubits);

% 2. Bob Measures in Random Bases
bob_bases = randi([0 1], 1, N_qubits);
bob_bits = alice_bits;
% Mismatched basis results in random 50% outcome
mismatch = (alice_bases ~= bob_bases);
bob_bits(mismatch) = randi([0 1], 1, sum(mismatch));

% 3. Sifting Key Stage (Keep bits where Alice & Bob chose identical bases)
match_idx = find(alice_bases == bob_bases);
sifted_alice = alice_bits(match_idx);
sifted_bob   = bob_bits(match_idx);

% 4. Calculate Quantum Bit Error Rate (QBER)
qber = mean(sifted_alice ~= sifted_bob);
fprintf('Sifted Key Length: %d bits | QBER: %.2f%%\n', length(sifted_alice), qber*100);

% 1. Synthesize Medical DICOM Slice Data (16-bit Grayscale)
mri_slice = uint16(phantom(256) * 4095);

% 2. Generate 256-bit AES Pseudo-Random Keystream
rng(12345, 'twister');
aes_keystream = uint16(randi([0 65535], 256, 256));

% 3. CTR-Mode Encryption (Bitwise XOR)
encrypted_slice = bitxor(mri_slice, aes_keystream);

% 4. Decryption Verification
decrypted_slice = bitxor(encrypted_slice, aes_keystream);
is_lossless = isequal(mri_slice, decrypted_slice);
fprintf('DICOM Lossless Reconstruction Verified: %d (Error = 0)\n', is_lossless);