Thứ nhất, luận án xây dựng bộ mã nhị phân 5 bit để mã hóa các ký tự sử
dụng trong các thuật toán giúp cho việc tăng tốc độ tính toán, giảm không gian
bộ nhớ lưu trữ hơn so với sử dụng bộ mã ASCII (sử dụng 8 bit).
Thứ hai, luận án đã đề xuất thuật toán mã hóa nhẹ trên cơ sở sử dụng kết
hợp 5 thanh ghi LFSR để tạo chuỗi bit giả ngẫu nhiên dùng cho quá trình mã
hóa bản rõ và giải mã bản mã.
Thứ ba, luận án xây dựng thuật toán tạo số giả ngẫu nhiên bằng phương
pháp đồng dư tuyến tính để sử dụng sinh các số giả ngẫu nhiên trong các yêu
cầu của các thuật toán trong luận án.
Thứ tư, luận án đã đề xuất một số giải pháp trao đổi 2 mầm khóa của mật
mã dòng đề xuất trong chương 2, cụ thể: đối với mầm khóa sử dụng dài hạn
𝑆𝐾1 (100 bit) sẽ dùng phương pháp giấu khóa này vào trong ảnh số để trao đổi
giữa các bên nhận và gửi; đối với khóa phiên (ngắn hạn) 𝑆𝐾2 (50 bit) sẽ sử dụng
các phương pháp đơn giản để trao đổi khóa như trình bày trong mục 3.2.3.
Trong thuật toán có kiểm tra xác thực khóa được trao đổi giữa 2 bên.
Những kết quả của luận án được trình bày cô đọng, ngắn gọn, rõ ràng,
dựa trên những cơ sở toán học và được chứng minh tính đúng đắn cũng như so
sánh, đánh giá và thực nghiệm. Các kết quả của luận án có khả năng ứng dụng
trong lý luận và thực tiễn, nhất là đối với lĩnh vực đảm bảo an ninh, an toàn cho
môi trường mạng IoT, góp phần trong công tác đấu tranh phòng, chống tội
phạm sử dụng công nghệ cao cho công tác của lực lượng Công an nhân dân.
158 trang |
Chia sẻ: Kim Linh 2 | Ngày: 11/11/2024 | Lượt xem: 29 | Lượt tải: 0
Bạn đang xem trước 20 trang tài liệu 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, để xem tài liệu hoàn chỉnh bạn click vào nút DOWNLOAD ở trên
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