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 toán lượng tin rò rỉ của dữ liệu bí mật Luận văn này mô tả thuật toá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
ĐẠ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 luận văn “Phân tích định lượng luồng tin bảo mật chương trình đa luồng” khơng phải chép luận văn cơng trình có từ trước Các số liệu, kết nêu luận văn trung thực chưa công bố cơng trình khác Tác giả luận văn Dương Tuấn Quang MỤC LỤC MỞ ĐẦU CHƯƠNG CƠ SỞ LÝ THUYẾT BẢO MẬT THÔNG TIN 1.1 Lý thuyết xác suất .4 1.2 Lý thuyết thông tin 1.2.1 Khái niệm thông tin 1.2.2 Lượng tin 1.3 Entropy 1.3.1 Shannon entropy 1.3.2 Min-entropy 10 1.4 Kết luận chương 10 CHƯƠNG 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 18 CHƯƠNG 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 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 chương trình đa luồng 19 3.1.3 Ảnh hưởng lập lịch 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ỉ 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ỉ chương trình đa luồng 24 3.2.3 Ví dụ minh hoạ 24 3.2.4 Ví dụ minh hoạ 26 3.2.5 Ví dụ minh hoạ 28 3.2.6 Ví dụ minh hoạ 30 3.3 Kết luận chương 34 CHƯƠNG 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ơ 35 4.2 Cấu trúc chung chương trình mơ 35 4.3 Thuật tốn chương trình mơ 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 tính tốn mơ 41 4.7 Đánh giá chương trình mơ 42 4.8 Kết luận chương 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ấn đề bảo mật chương trình đa luồng, đồng thời xây dựng công cụ mô tự động phân tích định lượng luồng tin chương trình đa luồng Cơng cụ dựa vào phương pháp phân tích định lượng người cơng lựa chọn lập lịch để thực thi chương trình đa luồng, từ suy số thơng tin định liệu bí mật Phương pháp lập lịch sử dụng để xây dựng mơ hình chuyển trạng thái chương trình đa luồng, tính tốn lượng tin rị rỉ liệu bí mật Luận văn mơ tả thuật tốn chương trình tổng hợp kết số ví dụ để kiểm chứng độ xác 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 trình ví dụ 26 3.2 Cây trạng thái chương trình ví dụ 28 3.3 Cây trạng thái chương trình ví dụ 29 3.4 Cây trạng thái chương trình ví dụ 32 4.1 Cấu trúc chương trình mơ 36 4.2 Thuật tốn chương trình mơ 38 4.3 Thuật tốn hàm cập nhật khơng gian trạng thái 39 4.4 Thuật tốn hàm tính tốn lượng tin rị rỉ 40 MỞ ĐẦU Tính cấp thiết đề tài Cùng với phát triển mạnh mẽ công nghệ thông tin, ngày có nhiều liệu xử lý, lưu trữ gửi mạng truyền thông Một thực trạng tránh khỏi người tham gia hệ thống có khả truy cập liệu Vấn đề quan trọng an tồn thơng tin phải đảm bảo việc truy cập nằm phạm vi cho phép Những thông tin bị truy cập đối tượng không cấp quyền xem thơng tin bị rị rỉ Hậu việc rị rỉ thơng tin ảnh hưởng nghiêm trọng đến người sử dụng khai thác hệ thống hợp pháp Có thể lấy số ví dụ vụ việc rị rỉ thơng tin cá nhân nhạy cảm bao gồm mã số tài khoản ngân hàng, thẻ tín dụng hay tiết lộ hồ sơ mang tính bí mật cơng ty, quốc gia mạng cơng cộng gần Chính vậy, điều quan trọng truyền thơng phải đảm bảo tính an tồn, bí mật thơng tin Có ba phương pháp sử dụng để bảo vệ thơng tin [9] là: điều khiển truy cập, mật mã, điều khiển luồng tin Điều khiển truy cập, ví dụ tường lửa, phương pháp phổ biến để bảo mật thơng tin Chỉ có đối tượng hợp pháp cấp quyền truy cập vào liệu Tuy nhiên, phương pháp không đảm bảo đối tượng hợp pháp không tiết lộ thông tin mật sau truy nhập thông tin Mật mã kỹ thuật mã hóa liệu q trình truyền dẫn lưu trữ Phương pháp ngăn chăn đối tượng không cấp phép truy cập vào liệu thơng qua q trình nghe hay can thiệp vào việc truyền tin hệ thống Cũng giống phương pháp điều khiển truy cập, phương pháp không đảm bảo việc người sử dụng hay chương trình phát tán liệu sau giải mã liệu Hơn nữa, kỹ thuật mã hóa sử dụng khơng hiệu quả, nhiều khả đối tượng truy cập bất hợp pháp giải mã liệu cách dễ dàng Lúc này, chức mã hóa khơng cịn ý nghĩa Một phương pháp bảo mật thơng tin mạnh điều khiển luồng tin, nghĩa giám sát thông tin di chuyển đến đâu hệ thống Một hệ thống xem khơng an tồn liệu mật cách lại lưu trữ vị trí mà đối tượng khơng cấp phép truy cập Phương pháp điều khiển luồng tin phát điều Đây điểm khác biệt so với hai phương pháp nêu trên; phương pháp điều khiển luồng tin đảm bảo thơng tin khơng bị phát tán (Smith, 2007) [10] Phương pháp điều khiển luồng tin đảm bảo mục tiêu ngăn chặn rò rỉ thơng tin hiệu hai phương pháp cịn lại Q trình phân tích luồng tin thực dựa hai phương pháp, định tính định lượng Nếu mục đích phân tích định tính nhằm xác định hệ thống có an tồn khơng cách trả lời câu hỏi hệ thống có bị rị rỉ thơng tin hay khơng, phân tích định lượng, ngồi việc xác định luồng di chuyển thơng tin, cịn cho phép xác định hay ước lượng lượng tin mà người công thu thập hệ thống bị bảo mật Hay nói cách khác, phân tích định lượng cho phép xác định có lượng thơng tin bị tiết lộ bên trường hợp hệ thống rị rỉ thơng tin Rõ ràng, phương pháp phân tích định lượng hiệu khía cạnh bảo mật thơng tin Vì vậy, lý luận văn tập trung nghiên cứu phương pháp định lượng luồng tin, cụ thể áp dụng bảo mật chương trình đa luồng Khái niệm đa luồng sử dụng để hệ thống hay chương trình có nhiều tiến trình hoạt động song song đồng thời với Mục đích nghiên cứu - Tìm hiểu cách thức phân tích định lượng luồng tin dựa lý thuyết thông tin [11], với số tham số như: entropy, min-entropy Áp dụng phân tích định lượng luồng tin cho chương trình đa luồng Xây dựng chương trình tính tốn mơ định lượng luồng tin kiểm thử số trường hợp cụ thể Đối tượng phạm vi nghiên cứu 3.1 Đối tượng nghiên cứu - Lý thuyết thông tin (Shannon, 1948) [11] Lý thuyết xác suất Lý thuyết định lượng luồng tin Chương trình đa luồng 3.2 Phạm vi nghiên cứu - Phương pháp định lượng luồng tin cho chương trình đa luồng Kiểm tra ứng dụng thuật tốn cho chương trình viết Matlab Phương pháp nghiên cứu Phương pháp luận luận văn kết hợp nghiên cứu lý thuyết mô để làm rõ nội dung đề tài Cụ thể sau: - Nghiên cứu phương pháp phân tích định lượng luồng tin dựa vào lý thuyết thông tin sở khái niệm entropy Nghiên cứu mơ hình chương trình đa luồng ứng dụng thuật tốn cho chương trình Sử dụng Matlab để thực tính tốn mơ định lượng luồng tin, áp dụng chương trình để kiểm thử số chương trình đa luồng đơn giản Đánh giá kết thực Ý nghĩa khoa học thực tiễn đề tài Bên cạnh thuật toán mang ý nghĩa khoa học lĩnh vực bảo mật thơng tin, đề tài cịn đề xuất phương án xây dựng chương trình mơ phỏng, tính tốn tự động giá trị thơng tin bị rị rỉ, có khả áp dụng cho số chương trình đơn giản thực tế Cấu trúc luận văn Nội dung luận văn gồm chương có nội dung sau: Chương – Cơ sở lý thuyết bảo mật thơng tin, trình bày vấn đề lý thuyết thông tin, xác suất, khái niệm lượng tin, khái niệm entropy làm sở cho lý thuyết bảo mật thông tin Chương – Lượng tin rị rỉ chương trình Giới thiệu hai khía cảnh bảo mật thơng tin, bao gồm định tính định lượng luồng thông tin, số phương pháp tính tốn lượng tin rị rỉ chương trình Chương – Lượng tin rị rỉ chương trình đa luồng Định nghĩa chương trình đa luồng, phương pháp tính tốn lượng tin rị rỉ chương trình đa luồng dựa mơ hình chuyển trạng thái thực thi chương trình đa luồng có ảnh hưởng lập lịch Chương – Xây dựng chương trình mơ phân tích định lượng luồng tin Mơ tả thuật tốn, hoạt động cơng cụ tự động định lượng luồng tin cách tính tốn lượng tin rị rỉ chương trình đa luồng Áp dụng vào số ví dụ để kiểm chứng tính xác chương trình CHƯƠNG CƠ SỞ LÝ THUYẾT BẢO MẬT THÔNG TIN 1.1 Lý thuyết xác suất Lý thuyết xác suất liên quan đến khảo sát có tính quy luật trình ngẫu nhiên Các trình ngẫu nhiên thí nghiệm cụ thể, đo đạc quan sát hay thu thập liệu từ kiện cụ thể đó, thực dựa tập điều kiện xác định trước Biến cố xảy phép thử kết phép thử thường có tính chất sau: độc lập, phân bố giống khơng thể dự đốn cách chắn Tần suất xuất biến cố trình ngẫu nhiên gọi xác suất biến cố Có thể lấy ví dụ gieo đồng tiền phép thử ngẫu nhiên, hai biến cố xảy xuất mặt sấp xuất mặt ngửa, với xác suất ½ số lần thử nhiều Lý thuyết xác suất gồm hai nhánh riêng biệt: phân bố xác suất rời rạc phân bố xác suất liên tục Định nghĩa cho phân bố xác suất rời rạc nêu bên Định nghĩa 1.1 [Biến ngẫu nhiên rời rạc] Một biến ngẫu nhiên rời rạc X hàm ánh xạ biến cố đến tập giá trị đếm (ví dụ, số nguyên), với giá trị nằm miền giá trị có xác suất lớn 0, xác định sau: 𝑋: 𝐷 → ℛ (𝐷 ), D tập hữu hạn với phân bố xác suất xác định, ℛ miền giá trị hữu hạn X Định nghĩa 1.2 [Phân bố xác suất rời rạc] Gọi D tập giá trị biến ngẫu nhiên rời rạc X Khi đó, phân bố xác suất rời rạc D xác định cho ∑𝑥∈𝐷 𝑃(𝑋 = 𝑥) = Định nghĩa 1.3 [Xác suất liên kết] Một cặp biến ngẫu nhiên (𝑥, 𝑦) liên kết với kiện tạo thành biến ngẫu nhiên liên kết Nếu x, y rời rạc, phân bố xác suất liên kết định nghĩa 𝑝𝑖𝑗 = 𝑃(𝑥 = 𝑥𝑖 , 𝑦 = 𝑦𝑗 ) Định nghĩa 1.4 [Xác suất có điều kiện] Xác suất y điều kiện biết x gọi xác suất có điều kiện định nghĩa là: 𝑝 (𝑦 | 𝑥 ) = 𝑝(𝑥, 𝑦) 𝑝 (𝑥 ) Case3_Thread22; [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_Thread22; [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 >= 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_Thread21; [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_Thread21; [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 == 3) % Line of code Case3_Thread21; [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 >= 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_Thread22; [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_Thread22; [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 >= 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 >= 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 >= 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 = : 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 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 bit integer O := 0; if (O = 0) then O = S / 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 % 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 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 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 >= 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 = : 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 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); ... CHƯƠNG 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 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 chương trình đa luồng ... mật thơng tin, bao gồm định tính định lượng luồng thơng tin, số phương pháp tính tốn lượng tin rị rỉ chương trình Chương – Lượng tin rị rỉ chương trình đa luồng Định nghĩa chương trình đa luồng,... LƯỢNG TIN RỊ RỈ CỦA CHƯƠNG TRÌNH ĐA LUỒNG 3.1 Bảo mật luồng thơng tin chương trình đa luồng 3.1.1 Chương trình đa luồng Có nhiều hệ thống yêu cầu tính bảo mật cao hoạt động dựa sở đa luồng tin