Luận án Nghiên cứu, phát triển một số thuật toán nâng cao khả năng bảo mật cho các thiết bị trong mạng IoT

Verlag, New York. 46. Kroese D.P., Taimre T., và Botev Z.I. (2011), Handbook of Monte Carlo Methods, Wiley. 47. Luo Y., Chai Q., Gong G. và cộng sự. (2010). A Lightweight Stream Cipher WG-7 for RFID Encryption and Authentication. 2010 IEEE Global Telecommunications Conference GLOBECOM 2010, Miami, FL, USA, IEEE, 1–6. 48. Mashal I., Alsaryrah O., Chung T. yaw và cộng sự. (2015). Choices for Interaction with Things on Internet and Underlying Issues. Ad Hoc Networks, 28. 49. Masoodi F. An Analysis of Linear Feedback Shift Registers in Stream Ciphers. International Journal of Computer Applications, 46. 50. Matsumoto M. và Nishimura T. (1998). Mersenne twister: a 623- dimensionally equidistributed uniform pseudo-random number generator. ACM Trans Model Comput Simul, 8(1), 3–30. 51. Maurer U.M. và Massey J.L. (1991). Local randomness in pseudorandom sequences. J Cryptology, 4(2), 135–149. 52. McEvoy R., Curran J., Cotter P. và cộng sự. (2006). Fortuna: cryptographically secure pseudo-random number generation in software and hardware. IET Irish Signals and Systems Conference (ISSC 2006), Dublin, Ireland, IEE, 457–462. 53. Menezes A.J., Oorschot P.C.V., Vanstone S.A. và cộng sự. (1997). Handbook of Applied Cryptography. 132 54. Micali S. và Schnorr C. (1991). Efficient, perfect polynomial random number generators. Journal of Cryptology, 3, 157–172. 55. Raza S. (2013), Lightweight security solutions for the internet of things, School of Innovation, Design and Engineering, Malardalen University, Malardalen University Press Dissertations. 56. Rukhin A., Soto J., Nechvatal J. và cộng sự. A Statistical Test Suite for Random and Pseudorandom Number Generators for Cryptographic Applications. 57. Rukhin A., Soto J., Nechvatal J. và cộng sự. A Statistical Test Suite for Random and Pseudorandom Number Generators for Cryptographic Applications. 58. Rukhin A., Soto J., Nechvatal J. và cộng sự. A Statistical Test Suite for Random and Pseudorandom Number Generators for Cryptographic Applications. 131. 59. Singer D. (2022). Secrets of Linear Feedback Shift Registers. Mathematics Magazine, 95(4), 368–375. 60. Singh U., Pandey A., và Gupta R. (2018). Design and implementation of lfsr (linear feedback shift register). International Journal of Industrial Electronics and Electrical Engineering, 6(7). 61. Stephen B. Wicke (2009), Error Control Systems for Digital Communication and Storage, Prentice Hall - New Jersey, Georgia Institute of Technology. 62. Tanh N.V. và Tri N.Q. (2020). A Comprehensive Security Solution for IOT Network with Integrated Technology of Improved Lightweight Encryption Mechanisms. International journal of simulation: systems, science & technology. 63. Turan M.S., Barker E., Kelsey J. và cộng sự. (2018), Recommendation for the entropy sources used for random bit generation, National Institute of Standards and Technology, Gaithersburg, MD. 133 64. U.Bokhari M., Alam S., và Syeed Masoodi F. (2012). Cryptanalysis Techniques for Stream Cipher: A Survey. IJCA, 60(9), 29–33. 65. Voros M. (2007), Algebraic attack on stream ciphers, Comenius University, Bratislava. 66. Win M.S.M. (2008). A New Approach to Feedback Shift Registers. 2(12). 67. Wu H. ACORN: A Lightweight Authenticated Cipher (v2). 68. Wu W. và Zhang L. (2011). LBlock: A Lightweight Block Cipher. Applied Cryptography and Network Security, Berlin, Heidelberg, Springer, 327–344. 69. (2001). Announcing the Advanced Encryption Standard (AES). Federal Information Processing Standards Publication 197, 51. 70. Alam S., Bokhari M., và Masoodi F. (2012). An Analysis of Linear Feedback Shift Registers in Stream Ciphers. International Journal of Computer Applications-IJCA, Volume 46, 46–49. 71. Barni M. (2018), Document and Image Compression, CRC Press. 72. Blum L., Blum M., và Shub M. (1986). A Simple Unpredictable Pseudo- Random Number Generator. SIAM Journal on Computing, 15(2), 364–383. 73. Chan C.-K. và Cheng L.M. (2004). Hiding data in images by simple LSB substitution. Pattern Recognition, 37, 469–474. 74. Furht B., Akar E., và Andrews W.A. (2018). Data Hiding in Digital Images. Digital Image Processing: Practical Approach. Springer International Publishing, Cham, 57–63. 75. Jeon S.Y., Ahn J.H., và Lee T.-J. (2016). Data Distribution in IoT Networks with Estimation of Packet Error Rate. 2016 10th International Conference on Next Generation Mobile Applications, Security and Technologies (NGMAST), 94–98. 76. Khemissa H. và Tandjaoui D. (2016). A novel lightweight authentication scheme for heterogeneous wireless sensor networks in the context of Internet of Things. 2016 Wireless Telecommunications Symposium (WTS), 1–6. 134 77. Lakha B. và Sharma R. (2016). Design and Analysis of Linear Feedback Shift Register (LFSR) using Gate Diffusion Input Technique. 78. Leander G., Zenner E., và Hawkes P. (2009). Cache Timing Analysis of LFSR-Based Stream Ciphers. Cryptography and Coding, Berlin, Heidelberg, Springer Berlin Heidelberg, 433–445. 79. Mohammadi M.S., Collings I., và Zhang Q. (2017). Simple Hybrid ARQ Schemes Based on Systematic Polar Codes for IoT Applications. IEEE Communications Letters, PP. 80. Nawir M., Amir A., Yaakob N. và cộng sự. (2016). Internet of Things (IoT): Taxonomy of security attacks. 2016 3rd International Conference on Electronic Design (ICED). 81. Neethu Natarajan T.J. Suvanam Sasidhar Babu, (2017). Secret Data Hiding Using Image Segmentation and Least Significant BIT (LSB) Insertion Steganography. International Journal of Pure and Applied Mathematics, 117. 82. Paar C. và Pelzl J. (2010). Stream Ciphers. Understanding Cryptography: A Textbook for Students and Practitioners. Springer Berlin Heidelberg, Berlin, Heidelberg, 29–54. 83. Raphael A. và Venkatachalam S. (2010). Secured Communication through Hybrid Crypto-Steganography. International Journal of Computer Science and Information Security, 8. 84. Shamsoshoara A., Korenda A., Afghah F. và cộng sự. (2019). A Survey on Hardware-based Security Mechanisms for Internet of Things. ArXiv. 85. Thakor V.A., Razzaque M.A., và Khandaker M.R.A. (2021). Lightweight Cryptography Algorithms for Resource-Constrained IoT Devices: A Review, Comparison and Research Opportunities. IEEE Access, 9, 28177–28193. 86. Zhu Y. và Hu Y. (2003). SNARE: a strong security scheme for network- attached storage. 22nd International Symposium on Reliable Distributed Systems, 2003 Proceedings. 135 PHỤ LỤC Phụ lục 1: Các tiêu chuẩn đánh giá chuỗi bit Cho dãy S = 𝑠0, 𝑠1, , 𝑠𝑛−1 là dãy nhị phân gồm n bit, 𝑠𝑖 ∈ {0,1}, 𝑖 = 0, 2, , 𝑛 − 1. Năm phép kiểm tra tính ngẫu nhiên của S như sau: Tiêu chuẩn 1: Kiểm tra tần số đơn (monobit test) Công thức thống kê: 𝑋1 = (𝑛0 − 𝑛1) 2 𝑛 (1) Trong đó: 𝑛0 là số bit 0 và 𝑛1 là số bit 1 tương ứng trong chuỗi mẫu S, n là độ dài chuỗi S (bit) và 𝑋1là kết quả. Mục tiêu của phép kiểm tra này là xác định xem số bit 0 và 1 trong chuỗi S có xấp xỉ bằng nhau như trong chuỗi ngẫu nhiên hay không. Nếu S là dãy ngẫu nhiên độc lập thì 𝑋1 có phân bố xấp xỉ với phân bố 𝜒2với 1 bậc tự do khi n ≥ 10 (trong thực tế n được khuyến cáo cần lớn trên 100 bit). Tiêu chuẩn 2: Kiểm tra bộ đôi (two-bit test) Công thức thống kê: 𝑋2 = 4 𝑛−1 (𝑛00 2 + 𝑛01 2 + 𝑛10 2 + 𝑛11 2 ) − 2 𝑛 (𝑛0 2 + 𝑛1 2)+1 (2) Trong đó: 𝑛0là số bit 0 và 𝑛1 là số bit 1, 𝑛00 là số lần xuất hiện cặp 00, 𝑛01 là số lần xuất hiện cặp 01, 𝑛10 là số lần xuất hiện cặp 10, 𝑛11 là số lần xuất hiện cặp 11 trong chuỗi S, n là độ dài chuỗi S (bit) và 𝑋2là kết quả. Mục tiêu của phép kiểm tra này là xác định xem số lần xuất hiện của các cặp 00, 01, 10, 11 (bộ đôi móc xích) trong chuỗi S có xấp xỉ bằng nhau như trong chuỗi ngẫu nhiên hay không. Nếu S là dãy ngẫu nhiên độc lập thì 𝑋2 có phân bổ xấp xỉ với phân bố 𝜒2với 2 bậc tự do khi n ≥ 21. Tiêu chuẩn 3: Kiểm tra Poker (Poker test) 136 Gọi m là một số nguyên dương sao cho ⌊ 𝑛 𝑚 ⌋ ≥ 5 𝑥 2𝑚và đặt k = ⌊ 𝑛 𝑚 ⌋ Chia chuỗi S thành k phần độ dài m rời nhau, 𝑛𝑖 là tần số xuất hiện loạt thứ i độ dài m với 1 ≤ i ≤ 2𝑚. Công thức thống kê: 𝑋3 = 2𝑚 𝑘 (∑𝑛𝑖 2 2𝑚 𝑖=1 ) − 𝑘 (3) Mục tiêu phép kiểm tra Poker xác định xem số lần xuất hiện từng chuỗi độ dài m trong chuỗi S có xấp xỉ bằng nhau như trong chuỗi ngẫu nhiên hay không. Nếu S là dãy đủ ngẫu nhiên và độc lập thì 𝑋3 có phân bổ xấp xỉ với phân bố 𝜒2 với 2𝑚-1 bậc tự do. Kiểm tra poker chính là tổng quát của kiểm tra tần số với m =1. Tiêu chuẩn 4: Kiểm tra loạt (Runs test) Công thức thống kê: 𝑋4 = ∑ (𝐵𝑖 − 𝑒𝑖) 2 𝑒𝑖 𝑘 𝑖=1 ) + ∑ (𝐺𝑖 − 𝑒𝑖) 2 𝑒𝑖 𝑘 𝑖=1 ) (4) Trong đó: 𝐵𝑖 và 𝐺𝑖 là số các loạt 1 (block) loạt 0 (gap) của chuỗi S, 𝑒𝑖 là trung bình các gap hoặc block độ dài i và được tính: 𝑒𝑖 = 𝑛 − 𝑖 + 3 2𝑖+2 Mục tiêu của phép kiểm tra này là xác định xem số loạt (loạt 0 hoặc loạt 1) với các độ dài khác nhau trong chuỗi S có giống như trong chuỗi ngẫu nhiên hay không. Gọi k là số nguyên i lớn nhất mà 𝑒𝑖 ≥ 5, gọi 𝐵𝑖 và 𝐺𝑖 là số các loạt 1 và loạt 0 có độ dài i tương ứng trong chuỗi S (1 ≤ i ≤ k) khi đó 𝑋4 có phân bố xấp xỉ 𝜒2 với 2k-2 bậc tự do. Tiêu chuẩn 5: Kiểm tra tự tương quan (Autocorrelation test) Gọi d là một giá trị nguyên cố định (1≤ d< n/2), đặt: 137 𝐴(𝑑) = ∑ (𝑆𝑖 ⊕ 𝑆𝑖+𝑑) 𝑛−𝑑−1 𝑖=0 𝐴(𝑑) là số bít trong S khác với S dịch đi d bit. Công thức thống kê được dùng là: 𝑋5 = 2 (𝐴(𝑑) − 𝑛 − 𝑑 2 ) √𝑛 − 𝑑 (5) Mục tiêu của phép kiểm tra này là kiểm tra sự tương quan giữa chuỗi S và chính nó dịch đi một số vị trí (không dịch quay vòng). Giá trị 𝑋5 xấp xỉ với phân bố chuẩn N(0,1) nếu n-d ≥10. Bởi vì các giá trị quá lớn của A(d) cũng không được mong đợi cũng như các giá trị quá nhỏ của A(d), phép kiểm tra hai phía cần được sử dụng. 138 Phụ lục 2: Các nền tảng mạng IoT phổ biến Khung IoT (Nhà phát triển) Smart things (Samsung) AWS IoT (Amazon) Calvin (Erisson) Brillo/Weave (Google) Kura (Eclipse) ARM Mbed (ARM) HomeKit (Apple) Azure IoT (Microsoft) Các thành phần kiến trúc + Phần mềm hỗ trợ đám mây + Thiết bị thông minh + SmartThings Hub + Ứng dụng SmartThings Home. + Dịch vụ đám mây + Thiết bị thông minh + Cổng thiết bị + Công cụ quy tắc + Đơn vị đăng ký + Bóng thiết bị + Tác nhân: thiết bị nhúng thông minh, điện thoại thông minh, đám mây, máy chủ. + Điện toán dựa trên luồng + thiết bị vật lý có Brillo/Android làm máy chủ OS + OTA + Dịch vụ đám mây dựa trên Java/OSGi. + Hệ điều hành Mbed + Trình kết nối thiết bị Mbed + Đám mây mbed + Máy khách mbed + MCU ARM Cortex-M + Home Conf. D.B. + HAP + API HomeKit + Thiết bị hỗ trợ HomeKit + Phần mềm hỗ trợ đám mây + Dịch vụ đám mây + Cổng thông minh đám mây + Thiết bị Ngôn ngữ lập trình Groovy Ngôn ngữ có thể sử dụng hàm API Calvin + Python + others Ngôn ngữ có thể nói chuyện qua Weave SDK Java + C++ + Khác + Swift + C hướng đối tượng + C + Node.js + Java + Python + .Net Phần cứng phụ thuộc SmartThings Hub AWS hub Không Không Không + ARM MCU + Apple tv + Cầu nối HomeKit Azure IoT Hub Phần mềm phụ thuộc Ứng dụng Home Không Không + Brillo OS + Weave SDK + JVM 7.0 hoặc mới hơn +Mbed OS iOS + watchOS + tvOS + Không 139 + Mbed Client HomeKit app. Phần cứng tương thích Tất cả các MCU hỗ trợ các giao thức truyền thông tương thích. Bất kỳ MCU nào có thể được cấu hình bằng nền tảng C, arduino hoặc Node.js Bất kỳ MCU nào có khả năng giao tiếp Bất kỳ MCU nào có bộ nhớ = 35 MB Các thiết bị dựa trên Linux hỗ trợ JVM 7. 0 + + Tất cả các thiết bị hỗ trợ công nghệ được cấp phép MFi của Apple + Tất cả các thiết bị đều có thể kết nối với cầu HomeKit Tất cả các thiết bị có RAM 64KB và RTC và hỗ trợ SHA-256 Giao thức ứng dụng hỗ trợ + HTTP + HTTP + WebSockets + MQTT + HTTP + HTTP + XMPP +CoAP + MQTT +CoAP + HTTP + MQTT + others + HTTP + HTTP + MQTT +AMQP Giao thức kết nối hỗ trợ + ZigBee + Z- wave + WiFi + BLE + WiFi + i2c + BT + others + WiFi + BLE + Ethernet + WiFi + BLE + WiFi + BLE + ZigBee + Z- wave + WiFi + ZigBee + Z-wave + others Bảo mật Xác thực + Giao thức OAuth/OAuth2. + X.509 Certificates + AWS IAM + AWS Cognito + Chứng chỉ X.509 + Nhận dạng dựa trên Sim + OAuth 2.0 + TEE + secure sockets + X.509 Certificates + standards other (mbed TLS) + Chữ ký khóa công khai/riêng Ed25519 + + Chứng chỉ X.509 + Chữ ký HMAC- SHA256 140 Khóa Curve25519 Điều khiển truy cập + Chế độ khả năng/ Quy tắc cấp quyền + Kỹ thuật hộp cát + IAM Roles + Rules Engine + Sandboxing + File cấu hình + SELinux + ACL + Sandboxing: UID&GID + Trình quản lý bảo mật + Chính sách thời gian chạy + uVisor + MPU + Sandboxing + Kiến trúc bảo mật iOS + Kỹ thuật ASLR + Chính sách Azure Active Directory + Quy tắc kiểm soát truy cập của trung tâm Azure IoT Kết nối + SSL/TLS + SSL/TLS + SSL/TLS + SSL/TLS + SSL/TLS +mbed TLS + TLS/DTLS + Bảo mật chuyển tiếp hoàn hảo + TLS/DTLS Mã hóa Giao thức AES 128 bit. AES 128 bit + các nguyên thủy khác Giao thức ECC Mã hóa toàn bộ đĩa được hỗ trợ bởi nhân Linux Nhiều nguyên thủy mật mã mbed TLS + Hardware Crypto. 256 bits AES + nhiều giao thức khác Nhiều nguyên thủy mật mã 141 Phụ lục 3: Mô phỏng thuật toán kiểm tra đa thức nguyên thủy Thuật toán def gf2_polynomial_x5_x2_1_primitive_check(): max_element = 2 ** 5 - 1 # Bắt đầu với phần tử '1' trong trường GF(2^5), biểu diễn ở dạng số nguyên element = 1 # Tập hợp để lưu trữ các phần tử đã sinh ra generated_elements = set() for _ in range(max_element): generated_elements.add(element) element <<= 1 # Nhân đa thức hiện tại với x (dịch bit sang trái) # Kiểm tra nếu kết quả lớn hơn 'max_element', # áp dụng đa thức x^5+ x^2+1 mô-đun 2 # Điều này tương đương với việc kiểm tra bit thứ 5 và nếu nó là 1, # thì thực hiện XOR với 0b100101 (đại diện cho x^5+ x^2+1) if element & 0b100000: # Kiểm tra bit thứ 5 # Áp dụng đa thức x^5+ x^2+1 mô-đun 2 element ^= 0b100101 element &= max_element # Áp dụng modulo với max_element return len(generated_elements) == max_element is_primitive_x5_x2_1 = gf2_polynomial_x5_x2_1_primitive_check() print(is_primitive_x5_x2_1) End 142 Phụ lục 4: Mô phỏng thuật toán sinh chuỗi bit giả ngẫu nhiên Thuật toán def f(x): return x[30] ^ x[2] ^ 1 def shift_left(register): out = register[0] for i in range(len(register) - 1): register[i] = register[i + 1] register[-1] = out def generate_LFSR_sequence(register, length): sequence = [] for _ in range(length): sequence.append(register[0]) feedback = f(register) shift_left(register) register[-1] = feedback return sequence print (sequence) def phi(j, t, y_values): if t == 1: return 0 else: # Kiểm tra để đảm bảo chỉ số không vượt quá độ dài của danh sách y_values if phi(j, t - 1, y_values) + psi(j, t - 1, y_values) + 1 < len(y_values): return phi(j, t - 1, y_values) + psi(j, t - 1, y_values) + 1 else: # Xử lý trường hợp chỉ số vượt quá độ dài của danh sách y_values # Ví dụ: return 0 hoặc xử lý khác phù hợp return 0 def psi(j, t, y_values): if t == 1: return 1 else: 143 # Kiểm tra để đảm bảo chỉ số không vượt quá độ dài của danh sách y_values if t - 1 >= 0 and j - 1 >= 0 and phi(j - 1, t - 1, y_values) + 18 < len(y_values): return psi(j - 1, t, y_values) ^ y_values[phi(j - 1, t - 1, y_values) + 18][j - 2] ^ 1 else: # Xử lý trường hợp chỉ số vượt quá độ dài của danh sách y_values # Ví dụ: return 0 hoặc xử lý khác phù hợp return 0 def generate_lambda_vector(t, y_values): lambda_vector = [] for j in range(1, 6): # i = phi(j, t) + 26 # Loại bỏ đối số thừa y_values i = phi(j, t, y_values) + 26 # Thêm đối số y_values if 0 <= i < len(y_values) and 0 <= j - 1 < len(y_values[i]): lambda_j = y_values[i][j - 1] lambda_vector.append(lambda_j) return lambda_vector # Ví dụ khởi tạo giá trị ban đầu S = [1,0,0,1,0,0,0,1,0,1,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1] y_values = [generate_LFSR_sequence(S.copy(), 5) for _ in range(5)] # Sinh các vector lambda lambda_vectors = [generate_lambda_vector(t, y_values) for t in range(1, 11)] # In các vector lambda for t, lambda_vector in enumerate(lambda_vectors, start=1): print(f"Lambda vector at t = {t}: {lambda_vector}") End 144 Phụ lục 5: Mô phỏng thuật toán mã hóa Thuật toán #bảng mã H binary_table = { 'A': [1, 0, 0, 0, 0], 'B': [0, 1, 0, 0, 0], 'C': [0, 0, 1, 0, 0], 'D': [0, 0, 0, 1, 0], 'E': [0, 0, 0, 0, 1], 'F': [1, 0, 1, 0, 0], 'G': [0, 1, 0, 1, 0], 'H': [0, 0, 1, 0, 1], 'I': [1, 0, 1, 1, 0], 'J': [0, 1, 0, 1, 1], 'K': [1, 0, 0, 0, 1], 'L': [1, 1, 1, 0, 0], 'M': [0, 1, 1, 1, 0], 'N': [0, 0, 1, 1, 1], 'O': [1, 0, 1, 1, 1], 'P': [1, 1, 1, 1, 1], 'Q': [1, 1, 0, 1, 1], 'R': [1, 1, 0, 0, 1], 'S': [1, 1, 0, 0, 0], 'T': [0, 1, 1, 0, 0], 'U': [0, 0, 1, 1, 0], 'V': [0, 0, 0, 1, 1], 'W': [1, 0, 1, 0, 1], 'X': [1, 1, 1, 1, 0], 'Y': [0, 1, 1, 1, 1], 'Z': [1, 0, 0, 1, 1], '3': [1, 1, 1, 0, 1], '4': [1, 1, 0, 1, 0], '5': [0, 1, 1, 0, 1], '7': [1, 0, 0, 1, 0], '8': [0, 1, 0, 0, 1], '9': [0, 0, 0, 0, 0] } # Hàm chuyển đổi giá trị từ ký tự sang nhị phân def char_to_binary(char): return binary_table[char] # Hàm chuyển đổi giá trị từ nhị phân sang ký tự def binary_to_char(binary): for char, bin_val in binary_table.items(): if bin_val == binary: return char return None # Hàm tính giá trị g1 từ vector nhị phân def g_1(alpha_vector): g1_value = sum([alpha_vector[j] * (2 ** (j)) for j in range(5)]) return g1_value % 32 # Hàm tính giá trị g2 từ vector nhị phân def g_2(alpha_vector): g2_value = sum([alpha_vector[j] * (2 ** (5 - j - 1)) for j in range(5)]) return g2_value % 32 # Hàm mã hóa theo thuật toán 1 def encode_algorithm_1(X, lambda_values): 145 n = len(X) encoded_values = [] for i in range(n): # Bước 2.1: Tính toán giá trị z_i và lambda_i z_i = g_2(X[i]) lambda_i = g_1(lambda_values[i % 32]) # Bước 2.2: Thực hiện mã hóa d_i = (z_i + lambda_i) % 32 encoded_values.append(d_i) return encoded_values # Hàm mã hóa theo thuật toán 2 def encode_algorithm_2(X, lambda_values): n = len(X) encoded_values = [] for i in range(n): # Bước 2.1: Mã hóa lần 1 c_i = [(x ^ l) for x, l in zip(X[i], lambda_values[i % 32])] # Bước 2.2: Tính toán giá trị lambda_i và c_i lambda_i = g_1(lambda_values[i % 32]) c_i_value = g_2(c_i) # Bước 2.3: Mã hóa lần 2 d_i = (c_i_value + lambda_i) % 32 encoded_values.append(d_i) return encoded_values #Lấy ví dụ cụ thể để minh họa # Lambda values - vector nhị phân 5 bit khóa lambda_values = [ [1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1], [1,0,1,0,0], [0,1,0,1,0], [0,0,1,0,1], [1,0,1,1,0], [0,1,0,1,1], [1,0,0,0,1], [1,1,1,0,0], [0,1,1,1,0], [0,0,1,1,1], [1,0,1,1,1], [1,1,1,1,1], [1,1,0,1,1], [1,1,0,0,1], [1,1,0,0,0], [0,1,1,0,0], [0,0,1,1,0], [0,0,0,1,1], [1,0,1,0,1], [1,1,1,1,0], [0,1,1,1,1], 146 [1,0,0,1,1], [1,1,1,0,1], [1,1,0,1,0], [0,1,1,0,1], [1,0,0,1,0], [0,1,0,0,1], [0,0,0,0,0] ] # Bản rõ X - vector nhị phân 5 bit X = [ [1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1], [1,0,1,0,0], [0,1,0,1,0], [0,0,1,0,1], [1,0,1,1,0], [0,1,0,1,1], [1,0,0,0,1], [1,1,1,0,0], [0,1,1,1,0], [0,0,1,1,1], [1,0,1,1,1], [1,1,1,1,1], [1,1,0,1,1], [1,1,0,0,1], [1,1,0,0,0], [0,1,1,0,0], [0,0,1,1,0], [0,0,0,1,1], [1,0,1,0,1], [1,1,1,1,0], [0,1,1,1,1], [1,0,0,1,1], [1,1,1,0,1], [1,1,0,1,0], [0,1,1,0,1], [1,0,0,1,0], [0,1,0,0,1], [0,0,0,0,0] ] # Mã hóa bằng thuật toán 1 encoded_values_1 = encode_algorithm_1(X, lambda_values) print("Encoded values (Algorithm 1):", encoded_values_1) # Mã hóa bằng thuật toán 2 encoded_values_2 = encode_algorithm_2(X, lambda_values) print("Encoded values (Algorithm 2):", encoded_values_2) End 147 Phụ lục 6: Mô phỏng thuật toán giải mã Thuật toán # Hàm giải mã cho thuật toán 1 def decode_algorithm_1(encoded_values, lambda_values): decoded_values = [] for d_i in encoded_values: # Bước 2.1: Tính toán giá trị lambda_i lambda_i = g_1(lambda_values[len(decoded_values) % 32]) # Bước 2.2: Tính toán giá trị z_i z_i = (d_i - lambda_i) % 32 # Bước 2.3: Chuyển đổi giá trị z_i thành vector nhị phân 5 bit binary_z_i = list(format(z_i, '05b')) # Bước 2.4: Chuyển đổi vector nhị phân thành ký tự char_z_i = ''.join([binary_to_char(''.join(binary_z_i[j:j+5])) for j in range(0, len(binary_z_i), 5)]) decoded_values.append(char_z_i) return decoded_values # Hàm giải mã cho thuật toán 2 def decode_algorithm_2(encoded_values, lambda_values): decoded_values = [] for d_i in encoded_values: # Bước 1: Giải mã lần 1 # Tính toán giá trị lambda_i lambda_i = g_1(lambda_values[len(decoded_values) % 32]) # Tính toán giá trị c_i c_i = (d_i - lambda_i) % 32 # Bước 2: Giải mã lần 2 # Chuyển đổi giá trị c_i thành vector nhị phân 5 bit binary_c_i = list(format(c_i, '05b')) # Tính toán (x_i) 148 x_i = [(int(binary_c_i[j]) ^ int(lambda_values[len(decoded_values) % 32][j])) for j in range(5)] # Chuyển đổi (x_i) thành ký tự char_x_i = ''.join([binary_to_char(''.join(map(str, x_i[j:j+5]))) for j in range(0, len(x_i), 5)]) decoded_values.append(char_x_i) return decoded_values # Giả sử dữ liệu lambda_values được cung cấp từ nguồn nào đó lambda_values = [[1, 0, 0, 0, 1], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]] # Giải mã các giá trị được mã hóa bằng thuật toán 1 decoded_values_1 = decode_algorithm_1(encoded_values_1, lambda_values) print("Decoded values (Algorithm 1):", decoded_values_1) # Giải mã các giá trị được mã hóa bằng thuật toán 2 decoded_values_2 = decode_algorithm_2(encoded_values_2, lambda_values) print("Decoded values (Algorithm 2):", decoded_values_2) End 149 Phụ lục 7: Mô phỏng thuật toán tạo số giả ngẫu nhiên Thuật toán def gcd(a, b): while b: a, b = b, a % b return a def check_conditions(a, b, n): # Kiểm tra điều kiện (i) if gcd(b, n) != 1: return False # Kiểm tra điều kiện (ii) của Định lý 1 d = gcd(a, n) if b % d != 0: return False # Kiểm tra điều kiện (ii) của Định lý 2 if gcd(a, n) != 1: # Kiểm tra a có là khả nghịch modulo n không return False # Kiểm tra điều kiện (iii) if n % 4 == 0 and (a - 1) % 4 != 0: return False return True def solve_linear_congruence(a, b, n, x_0, m): if not check_conditions(a, b, n): print("Không thỏa mãn các điều kiện để giải phương trình.") return [] solutions = [] x = x_0 for _ in range(m): solutions.append(x) x = (a * x + b) % n return solutions 150 # Các giá trị đầu vào a = 7 b = 5 n = 27 x_0 = 3 m = 27 # Kiểm tra các điều kiện và giải phương trình solutions = solve_linear_congruence(a, b, n, x_0, m) if solutions: print("Giá trị của phương trình đồng dư tuyến tính:", solutions) else: print("Không thỏa mãn các điều kiện để giải phương trình.") End 151 Phụ lục 8: Mô phỏng thuật toán giấu và trích chọn khóa bí mật trong ảnh Thuat toan # Định nghĩa các hàm H = np.array([ [1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1], [0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1], [0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1] ]) # Hàm chuyển đổi khóa thành các khối nhị phân 5 bit def convert_to_binary_blocks(secret_key): binary_blocks = [] for i in range(0, len(secret_key), 5): block = secret_key[i:i+5] binary_blocks.append(block) return binary_blocks # Hàm tạo ảnh thứ cấp từ ảnh đa cấp xám và khởi điểm giấu tin def create_secondary_image(image, i_0, num_blocks): secondary_image = [] for i in range(num_blocks): block = image[i_0 + i] secondary_image.append(block) return secondary_image # Hàm tính toán các vector (z_i) def calculate_z_vectors(secret_key_blocks, secondary_image, H): z_vectors = [] for i in range(len(secret_key_blocks)): z_vector = np.bitwise_xor(secret_key_blocks[i], H @ secondary_image[i]) z_vectors.append(z_vector) return z_vectors 152 # Hàm thực hiện biến đổi ảnh thứ cấp def modify_secondary_image(secondary_image, z_vectors, H): for i in range(len(z_vectors)): for j in range(len(z_vectors[i])): if H[:, j].tolist() == z_vectors[i].tolist(): secondary_image[i][j] ^= 1 return secondary_image # Hàm tính toán checksum def calculate_checksum(secret_key, i_0): checksum = 0 for bit in secret_key: checksum ^= bit checksum ^= i_0 return checksum # Hàm trích chọn khóa bí mật từ ảnh S def extract_secret_key_from_image(S, H, i_0): checksum = S[0] z_vectors = [] for i in range(20): z_vector = S[i_0 + i][1:] z_vectors.append(z_vector) m_vectors = [] for z_vector in z_vectors: m_vector = np.dot(H, z_vector) m_vectors.append(m_vector) secret_key = '' for m_vector in m_vectors: for bit in m_vector: secret_key += str(bit % 2) new_checksum = 0 for bit in secret_key: new_checksum ^= int(bit) 153 new_checksum ^= i_0 if checksum == new_checksum: return secret_key else: return None #Thực hiện chương trình # Tạo ảnh đa cấp xám và ma trận H image = np.random.randint(0, 2, size=(20, 32)) # Khởi điểm giấu tin i_0 = np.random.randint(0, 20) # Khởi tạo khóa bí mật secret_key = np.random.randint(0, 2, size=100) # Bước 1: Chuyển khóa thành các khối nhị phân 5 bit secret_key_blocks = convert_to_binary_blocks(secret_key) # Bước 2: Tạo ảnh thứ cấp secondary_image = create_secondary_image(image, i_0) # Bước 3: Tính toán các vector (z_i) z_vectors = calculate_z_vectors(secret_key_blocks, secondary_image, H) # Bước 4: Thay đổi các bit LSB trong ảnh thứ cấp modified_secondary_image = modify_secondary_image(secondary_image, z_vectors, H) # Bước 5: Tính toán checksum checksum = calculate_checksum(secret_key, i_0) # Bước 6: Trích chọn khóa bí mật từ ảnh S extracted_key = extract_secret_key_from_image(modified_secondary_image, H, i_0) # Kiểm tra và in kết quả if extracted_key is not None: print("Khóa bí mật được trích chọn: ", extracted_key) else: print("Không thể trích chọn khóa bí mật.") End 154 Phụ lục 9: Mô phỏng thuật toán tạo khóa chung Thuật toán def encode_sequence(sequence, m, d): # Bảng mã T T = { 'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25, '3': 26, '4': 27, '5': 28, '7': 29, '8': 30, '9': 31 } print('Mầm khóa ban đầu:', sequence) # Tạo dãy x(md) bằng cách lặp lại chuỗi ban đầu x_md = sequence * (m * d // len(sequence) + 1) x_md = x_md[:m * d] print('Chuỗi khóa:', x_md) # Chuyển đổi dãy x(md) thành dãy số dựa vào mã T x_md_ascii = [T[char] for char in x_md] #x_md_ascii = [T(char) for char in x_md] print('Dãy số chuyển đổi từ chuỗi khóa:', x_md_ascii) # Khởi tạo giá trị mã ma_hoa=1 ma_hoa = 1 x_md_ascii_cp = x_md_ascii.copy() #print('x_md_ascii_cp lúc đầu:', x_md_ascii_cp) # Mã hóa dãy x(md) encoded_sequence = [] for i in range(m * d): # Kiểm tra xem dãy đã hết hay chưa if all(x == -1 for x in x_md_ascii): break # Tìm giá trị nhỏ nhất chưa được mã hóa và khác -1 155 min_char = min(x for x in x_md_ascii if x != -1) #print('min_char', i, ':', min_char) # Nếu giá trị đã được mã hóa thì tiếp tục với giá trị tiếp theo if min_char in encoded_sequence: continue # Mã hóa giá trị và thêm vào dãy mã hóa encoded_sequence.append(min_char) #print('encoded_sequence:', encoded_sequence) # Thay thế giá trị đã được mã hóa trong dãy x(md) bằng giá trị mã for j in range(m * d): if x_md_ascii[j] == min_char: x_md_ascii_cp[j] = ma_hoa ma_hoa += 1 x_md_ascii[j] = -1 #print('x_md_ascii:', x_md_ascii) print('Bảng mã hóa chuỗi khóa:', x_md_ascii_cp) # Bước 3: Lập bảng (ma trận) kích thước m x d: B B = [] index = 0 for i in range(m): row = [] for j in range(d): if index < len(x_md_ascii_cp): row.append(x_md_ascii_cp[index]) index += 1 B.append(row) print("Ma trận B:") for row in B: print(row) # Bước 4: Tính tổng các số trong mỗi cột của B và lưu vào dãy z z = [(sum(map(int, col)) % 26) for col in zip(*B)] print("Khóa chung dạng số:", z) 156 # Bước 5: Chuyển dãy z sang ký tự dựa vào bảng mã T decoded_sequence = '' for i in range(len(z)): if i < len(z): decoded_sequence += [key for key, value in T.items() if value == z[i]][0] return decoded_sequence # Mã hóa dãy ký tự encoded_sequence = encode_sequence(sequence, m, d) #print("Chuỗi ký tự ban đầu:", sequence) print("Khóa chung dạng ký tự:", encoded_sequence) End