Phân tích định lượng luồng tin trong bảo mật chương trình đa luồng

..

ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC BÁCH KHOA


DƯƠNG TUẤN QUANG

PHÂN TÍCH ĐỊNH LƯỢNG LUỒNG TIN
TRONG BẢO MẬT CHƯƠNG TRÌNH ĐA LUỒNG

Chuyên ngành
Mã số

: Kỹ thuật điện tử
: 60.52.02.03

LUẬN VĂN THẠC SĨ KỸ THUẬT

Người hướng dẫn khoa học : TS. NGÔ MINH TRÍ

Đà Nẵng, năm 2017


LỜI CAM ĐOAN

Tôi xin cam đoan nội dung của luận văn “Phân tích định lượng luồng tin trong
bảo mật chương trình đa luồng” khơng phải là bản sao chép của bất cứ luận văn hoặc
cơng trình đã có từ trước. Các số liệu, kết quả nêu trong luận văn là trung thực và
chưa từng được ai công bố trong bất kỳ cơng trình nào khác.

Tác giả luận văn

Dương Tuấn Quang


MỤC LỤC
MỞ ĐẦU ....................................................................................................................1
CHƯƠNG 1. CƠ SỞ LÝ THUYẾT BẢO MẬT THÔNG TIN ............................4
1.1. Lý thuyết xác suất .............................................................................................4
1.2. Lý thuyết thông tin ............................................................................................5
1.2.1. Khái niệm thông tin ....................................................................................5
1.2.2. Lượng tin ....................................................................................................6
1.3. Entropy..............................................................................................................8
1.3.1. Shannon entropy .........................................................................................8
1.3.2. Min-entropy ..............................................................................................10
1.4. Kết luận chương 1 ...........................................................................................10
CHƯƠNG 2. LƯỢNG TIN RÒ RỈ CỦA CHƯƠNG TRÌNH .............................11
2.1. Bảo mật luồng thơng tin .................................................................................11
2.1.1. Phân tích định tính luồng thơng tin ..........................................................12
2.1.2. Phân tích định lượng luồng thơng tin ......................................................12
2.2. Lượng tin rị rỉ .................................................................................................14
2.2.1. Lượng tin rò rỉ theo Shannon entropy ......................................................16
2.2.2. Lượng tin rò rỉ theo min-entropy .............................................................17
2.3. Kết luận chương 2 ...........................................................................................18
CHƯƠNG 3. LƯỢNG TIN RỊ RỈ CỦA CHƯƠNG TRÌNH ĐA LUỒNG ......19
3.1. Bảo mật luồng thơng tin trong chương trình đa luồng ...................................19
3.1.1. Chương trình đa luồng .............................................................................19
3.1.2. Tính bảo mật của chương trình đa luồng .................................................19
3.1.3. Ảnh hưởng của bộ lập lịch trong chương trình đa luồng ........................20
3.1.4. Mơ hình chương trình đa luồng ...............................................................21

3.2. Lượng tin rị rỉ của chương trình đa luồng .....................................................22
3.2.1. Lượng tin rị rỉ theo vệt chương trình ......................................................22
3.2.2. Lượng tin rị rỉ của chương trình đa luồng ..............................................24
3.2.3. Ví dụ minh hoạ 1 ......................................................................................24


3.2.4. Ví dụ minh hoạ 2 ......................................................................................26
3.2.5. Ví dụ minh hoạ 3 ......................................................................................28
3.2.6. Ví dụ minh hoạ 4 ......................................................................................30
3.3. Kết luận chương 3 ...........................................................................................34
CHƯƠNG 4. XÂY DỰNG CHƯƠNG TRÌNH MƠ PHỎNG PHÂN TÍCH ĐỊNH
LƯỢNG LUỒNG TIN ............................................................................................35
4.1. Tổng quan chương trình mơ phỏng ................................................................35
4.2. Cấu trúc chung của chương trình mơ phỏng...................................................35
4.3. Thuật tốn chương trình mơ phỏng ................................................................37
4.3.1. Thuật tốn phân tích khơng gian trạng thái .............................................37
4.3.2. Thuật tốn tính tốn lượng tin rị rỉ .........................................................39
4.4. Tính tốn lượng tin rị rỉ với min-entropy ......................................................40
4.5. Tính tốn lượng tin rị rỉ với Shannon entropy ...............................................41
4.6. Kết quả tính tốn mơ phỏng............................................................................41
4.7. Đánh giá chương trình mơ phỏng ...................................................................42
4.8. Kết luận chương 4 ...........................................................................................42
KẾT LUẬN VÀ KIẾN NGHỊ ................................................................................43
DANH MỤC TÀI LIỆU THAM KHẢO ..............................................................44
PHỤ LỤC


PHÂN TÍCH ĐỊNH LƯỢNG LUỒNG TIN TRONG BẢO MẬT CHƯƠNG
TRÌNH ĐA LUỒNG
Học viên: Dương Tuấn Quang

Chuyên ngành: Kỹ thuật điện tử

Mã số: 60.52.02.03 Khóa: K31 KTĐT
ĐHĐN

Trường Đại học Bách khoa –

Tóm tắt – Luận văn nghiên cứu về vấn đề bảo mật trong chương trình đa luồng, đồng
thời xây dựng một cơng cụ mơ phỏng tự động phân tích định lượng luồng tin của
chương trình đa luồng. Cơng cụ này dựa vào phương pháp phân tích định lượng trong
đó người tấn công sẽ lựa chọn bộ lập lịch để thực thi chương trình đa luồng, từ đó có
thể suy ra được một số thông tin nhất định về dữ liệu bí mật. Phương pháp lập lịch
được sử dụng để xây dựng mơ hình chuyển trạng thái của chương trình đa luồng, và
tính tốn lượng tin rị rỉ của dữ liệu bí mật. Luận văn này mơ tả thuật tốn của chương
trình cũng như tổng hợp kết quả của một số ví dụ để kiểm chứng độ chính xác của
chương trình.
Từ khóa – bảo mật; đo lường; định lượng luồng tin; lượng tin rị rỉ; cơng cụ;

QUANTITATIVE INFORMATION FLOW ANALYSIS OF MULTITHREADED PROGRAM
Abstract – This thesis studies the security of multi-threaded programs and presents a
tool for analysing quantitative information flow (QIF) for multi-threaded programs
written in a core imperative language. The aim of the tool is to measure the leakage
of secret data. The tool is based on a method of the quantitative analysis where the
attacker is able to select the scheduling policy to attack the program. The scheduling
policy is used to construct the execution model of the program. We outline the
workings of the tool and summarise results derived from running the tool on a range
of case studies.
Keywords – security; measurement; quantitative information flow; information
leakage; tool;

DANH MỤC CÁC HÌNH
Số hiệu

Tên hình

Trang

3.1.

Cây trạng thái chương (ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
Case3_Thread1;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra
nsition2,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code

Case3_Thread1;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition2,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
elseif (x == 4)
% Line of code
Case3_Thread22;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];


prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1
secret = secret_temp(m,:);
% Line of code
Case3_Thread21;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end

else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case3_Thread21;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
Case3_Thread1;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra
nsition2,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code

Case3_Thread1;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition2,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
end


end
% PROCESS DATA
% Create another structure array to hold all "end state" elements
ProbTerminate =
struct('state',{},'observe',{},'secret',{},'probdis',{},'probtrace',{});
for k = 1 : length(ProbEnv)
thisStruct = ProbEnv(k);
thisString = thisStruct.state;
if strcmp(thisString, 'end')
ProbTerminate = [ProbTerminate,thisStruct];
end
end
% Remove the identical elements in structure array
isUnique = true(size(ProbTerminate));
for ii = 1:length(ProbTerminate)-1
for jj = ii+1:length(ProbTerminate)
if isequal(ProbTerminate(ii),ProbTerminate(jj))
isUnique(ii) = false;
break;
end

end
end
ProbTerminate(~isUnique) = [];
% CALCULATE LEAKAGE
% Calculate final uncertainty
% Renyi = zeros(1,length(ProbTerminate));
% final_uncertainty = 0;
%
% for i=1:length(ProbTerminate)
%
Renyi(i) = -log2(max(ProbTerminate(i).probdis));
%
final_uncertainty = final_uncertainty + ProbTerminate(i).probtrace
.* Renyi(i);
% end
%
% % Calculate leakage
% initial_uncertainty = -log2(max(initial_distribution));
%
% leakage = initial_uncertainty - final_uncertainty;
%
% disp('Leakage of program'); disp(leakage);
% Calculate final uncertainty
Renyi = zeros(1,length(ProbTerminate));
Shannon = zeros(1,length(ProbTerminate));
final_uncertainty_Renyi = 0;
final_uncertainty_Shannon = 0;
for i=1:length(ProbTerminate)
Renyi(i) = -log2(max(ProbTerminate(i).probdis));

Shannon(i) = -sum(ProbTerminate(i).probdis .*
log2(ProbTerminate(i).probdis));
final_uncertainty_Renyi = final_uncertainty_Renyi +
ProbTerminate(i).probtrace .* Renyi(i);
final_uncertainty_Shannon = final_uncertainty_Shannon +
ProbTerminate(i).probtrace .* Shannon(i);
end
% Calculate leakage
secret = [0 1 2 3];
[initial_uncertainty_Renyi initial_uncertainty_Shannon] =
entropy(secret,initial_distribution);
leakage_Renyi = initial_uncertainty_Renyi - final_uncertainty_Renyi;
leakage_Shannon = initial_uncertainty_Shannon final_uncertainty_Shannon;
disp('Leakage of program:'); disp(leakage_Renyi); disp(leakage_Shannon);

Case4_QIF.m
%
%
%
%
%
%
%
%

-------------------------------------------------------- Quantitative informative flow ------------------------------------------------------------------Program, S is 4 bit integer
O := 0;
if (O = 0) then O = S / 8 else O = S mod 2; || O := 1;
S = S mod 4;

O := S || O := 0;

clear all;
close all;
% Multithreaded program
N = 1; % Number of times to run program
% C1 || C2 ..... C3 || C4
% 4 possible cases: (1) C1 C2 C3 C4, (2) C1 C2 C4 C3, (3) C2 C1 C3 C4,
(4) C2 C1 C4 C3
% Declare variables with distribution
secret = [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15];
initial_distribution = [.0625 .0625 .0625 .0625 .0625 .0625 .0625 .0625
.0625 .0625 .0625 .0625 .0625 .0625 .0625 .0625];
prob_distribution = initial_distribution;
observe = [];
thread_prob = [0.25 0.25 0.25 0.25];
global state;
state = 1;
state_end = 'end';
prob_trace = 1;


ProbEnv = struct;
ProbEnv.state = state;
ProbEnv.observe = observe;
ProbEnv.secret = secret;
ProbEnv.probdis = prob_distribution;
ProbEnv.probtrace = prob_trace;
state = state + 1;
% STATE SPACE EXPLORATION

for x=1:4
% Random choose between Thread1 or Thread2 with uniform distribution
%
r = rand;
%
x = sum(r >= cumsum([0, thread_prob]));
%
x = 1; % Testing purpose
% Update distribution at each line of code
secret = [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15];
prev_probtrace = 1;
observe = 0;
if (x==1)
% Case 1: C1 C2 C3 C4
% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1
secret = secret_temp(m,:);
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition2] =

ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end


prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
transitionx = 0;
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
secret = mod(secret,2);
Case4_Thread3;
[ProbSpace,state,number_of_transition3] =

ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
transitionx = transitionx + number_of_transition3;
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
secret = mod(secret,2);
Case4_Thread3;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if transitionx >= 2
for m = 1:transitionx
secret_temp1(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp1(m,:) = ProbEnv(length(ProbEnv)m+1).probdis;
end
for m = 1:transitionx
secret = secret_temp1(m,:);
% Line of code
Case4_Thread4;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,probdis_temp1(m,:),transitionx,
prev_probtrace);

ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition3
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread4;


[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition3, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
elseif (x==3)
% (Case 3) C2 C1 C3 C4
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1
secret = secret_temp(m,:);

% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
secret = mod(secret,2);
Case4_Thread3;

[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
secret = mod(secret,2);
Case4_Thread3;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
Case4_Thread4;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra

nsition2, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread4;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition2, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
elseif (x==2)
% (Case 2) C1 C2 C4 C3
% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1


secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1

secret = secret_temp(m,:);
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
secret = mod(secret,2);
Case4_Thread4;

[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
secret = mod(secret,2);
Case4_Thread4;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;


if number_of_transition3 >= 2
for m = 1:number_of_transition3
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition3
secret = secret_temp(m,:);
% Line of code
Case4_Thread3;
[ProbSpace,state,number_of_transition4] =

ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra
nsition3, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition3
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread3;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition3, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
elseif (x==3)
% (Case 3) C2 C1 C3 C4
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1
secret = secret_temp(m,:);

% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread1;


[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
secret = mod(secret,2);

Case4_Thread3;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
secret = mod(secret,2);
Case4_Thread3;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp1(m,:) = ProbEnv(length(ProbEnv)m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
Case4_Thread4;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra

nsition2, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;


% Line of code
Case4_Thread4;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition2, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
elseif (x==4)
% (Case 4) C2 C1 C4 C3
% Line of code
Case4_Thread2;
[ProbSpace,state,number_of_transition1] =
ProbUpdate(state,'',observe,secret,prob_distribution,1,'begin');
ProbEnv = [ProbEnv,ProbSpace];
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition1 >= 2
for m = 1:number_of_transition1
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition1

secret = secret_temp(m,:);
% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition1
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread1;
[ProbSpace,state,number_of_transition2] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition1,prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition2 >= 2
for m = 1:number_of_transition2
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition2
secret = secret_temp(m,:);
% Line of code
secret = mod(secret,2);

Case4_Thread4;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,probdis_temp(m,:),number_of_transition
2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition2
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
secret = mod(secret,2);
Case4_Thread4;
[ProbSpace,state,number_of_transition3] =
ProbUpdate(state,'',observe,secret,ProbSpace(length(ProbSpace)).probdis,n
umber_of_transition2,0.5 * prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
prev_probtrace = ProbSpace(length(ProbSpace)).probtrace;
if number_of_transition3 >= 2
for m = 1:number_of_transition3
secret_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).secret;
probdis_temp(m,:) = ProbEnv(length(ProbEnv)-m+1).probdis;
end
for m = 1:number_of_transition3
secret = secret_temp(m,:);
% Line of code
Case4_Thread3;
[ProbSpace,state,number_of_transition4] =

ProbUpdate(state,state_end,observe,secret,probdis_temp(m,:),number_of_tra
nsition3, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
else
for m = 1:number_of_transition3
secret = ProbEnv(length(ProbEnv)).secret;
% Line of code
Case4_Thread3;
[ProbSpace,state,number_of_transition4] =
ProbUpdate(state,state_end,observe,secret,ProbSpace(length(ProbSpace)).pr
obdis,number_of_transition3, prev_probtrace);
ProbEnv = [ProbEnv,ProbSpace];
end
end
end
end
% PROCESS DATA
% Create another structure array to hold all "end state" elements
ProbTerminate =
struct('state',{},'observe',{},'secret',{},'probdis',{},'probtrace',{});
for k = 1 : length(ProbEnv)
thisStruct = ProbEnv(k);


thisString = thisStruct.state;
if strcmp(thisString, 'end')
ProbTerminate = [ProbTerminate,thisStruct];
end
end

% CALCULATE LEAKAGE
% Calculate final uncertainty
Renyi = zeros(1,length(ProbTerminate));
Shannon = zeros(1,length(ProbTerminate));
final_uncertainty_Renyi = 0;
final_uncertainty_Shannon = 0;
for i=1:length(ProbTerminate)
Renyi(i) = -log2(max(ProbTerminate(i).probdis));
Shannon(i) = -sum(ProbTerminate(i).probdis .*
log2(ProbTerminate(i).probdis));
final_uncertainty_Renyi = final_uncertainty_Renyi +
ProbTerminate(i).probtrace .* Renyi(i);
final_uncertainty_Shannon = final_uncertainty_Shannon +
ProbTerminate(i).probtrace .* Shannon(i);
end
% Calculate leakage
secret = [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15];
[initial_uncertainty_Renyi initial_uncertainty_Shannon] =
entropy(secret,initial_distribution);
leakage_Renyi = initial_uncertainty_Renyi - final_uncertainty_Renyi;
leakage_Shannon = initial_uncertainty_Shannon final_uncertainty_Shannon;
disp('Leakage of program:'); disp(leakage_Renyi); disp(leakage_Shannon);