.2 Sơ đồ khối hệ thống kết hợp hoán vị và mã hóa số học phân tách khoảng

Hình 3.1 Minh họa cách phân tách miền phân bố

(a)

Trong sơ đồ này bƣớc hoán vị đầu tiên áp dụng cho các chuỗi đầu vào, sau đó sử dụng mã hóa số học phân tách khoảng và hoán vị lần thứ hai đƣợc áp dụng cho các bit đƣợc sinh ra bởi quá trình mã hóa. Một dãy khóa là đầu vào cho một key scheduler lần lƣợt cung cấp thông tin khóa cho cả hai bƣớc hoán vị và mã hóa số học phân tách khoảng.

Có nhiều cách hoán vị nhƣng theo các tác giả trên việc hoán vị dựa theo ma trận và khóa. Đầu tiên sắp xếp dãy đầu vào theo một ma trận sau đó hoán vị theo hàng, cột, từ ma trận đã đƣợc hoán vị ta xây dựng chuỗi đầu vào cho việc mã hóa. Khi giải mã ta hoán vị ngƣợc lại để đƣợc chuỗi ban đầu. Theo cách này độ bảo mật của phƣơng pháp đã đƣợc cải thiện rõ rệt nhƣng vẫn chƣa thực sự an toàn.

Tóm lại, những mô hình trên có miền phân bố (xác suất của các ký tự) là cố định (miền phân bố chỉ là một hàm của ký tự), gần đây có nhiều nghiên cứu đề xuất mô hình động nghĩa là xác suất của các ký tự không phải là cố định trong cả quá trình mã hóa [10] [16], dựa vào ý tƣởng của RAC chúng tôi đề xuất một mô hình mới. Trong mô hình này miền phân bố của các ký tự đƣợc xác định bởi một hàm phụ thuộc vào 3 yếu tố: ký tự hiện tại, khóa K và khóa H. Cụ thể thuật toán nhƣ sau:

Input:

- Bản rõ kt[i] (i = 1, 2…., n)

- Khóa K = {k1, k2, …ku} với ki = 0,1,…255 - Khóa H = {h1, h2, …hv} với hi = 0,1

Output: code (mã số của bàn rõ)

Bƣớc chuẩn bị: Lập bảng miền phân bố của các ký tự trong bản rõ

Thuật toán mã hóa:

T0 = [0, D)

for(i=1; i ≤ n; i++) {

1. Xác định P(kt[i]) dựa vào kt[i] và bảng miền phân bố 2. Xác định P(kt*

[i]) bằng cách dịch chuyển P(kt[i]) nhƣ sau:

a. Nếu hi = 0 thì dịch trái P(kt[i]) với bƣớc dịch bằng ki b. Nếu hi =1 thì dịch phải P(kt[i]) với bƣớc dịch bằng ki 3. Ti = Ti-1 ← P(kt*[i])

Kết thúc thuật toán, mã của văn bản là một giá trị thuộc Tn

Thuật toán giải mã:

code[1] = code; Xác định P(kt*

[1]) bằng cách tra xem code[1] thuộc miền phân bố của ký tự nào Tìm P(kt[1]) bằng cách dịch chuyển P(kt*[1]) nhƣ sau:

a. Nếu h1 = 0 thì dịch phải P(kt*[1]) với bƣớc dịch k1 b. Nếu h1 =1 thì dịch trái P(kt*[1]) với bƣớc dịch k1

Xác định kt[1] dựa vào P(kt*

[1]) for (i=2 ; i ≤ n; i++)

{

1. code[i] = P(kt*[i]) → code[i-1] 2. Xác định P(kt*

[i+1]) dựa vào code[i]

3. Xác định P(kt[i+1]) bằng cách dịch P(kt*[i+1]) nhƣ sau:

a. Nếu hi = 0 thì dịch phải P(kt*[i+1]) với bƣớc dịch ki b. Nếu hi =1 thì dịch trái P(kt*[i+1]) với bƣớc dịch ki

4. Xác định kt[i] dựa vào P(kt[i+1]) }

Ví dụ:

Bản rõ: CABAB (n=5)

Bƣớc chuẩn bị: Lập bảng miền phân bố của bản rõ với D = 1000

STT Ký tự Tần suất xh Miền phân bố low_range hi_range

1 A 2 [0 – 400) 0 400

2 B 2 [400 – 800) 400 800

3 C 1 [800 – 1000) 800 1000

Giả sử 2 khóa K và H đƣợc sinh ngẫu nhiên và có giá trị nhƣ sau:

K = {2,0,1,1} H={0,1,1,0}

Thuật toán mã hóa thực hiện nhƣ sau:

T0 = [0, 1000) i=1:

kt[1]= C, P(kt[1]) = P(C) = [800, 1000) ;

h1=0 => miền phân bố dịch trái với bƣớc dịch k1 = 2 thành miền phân bố của A hay P(kt[1]) dịch chuyển thành P(kt*[1]) = [0,400)

T1 = T0P(kt[1])* = [0,1000)  [0,400) = [0, 400) (theo công thức 3.4 và 3.5) i=2:

kt[2]= A, P(kt[2]) = P(A) = [0, 400) ;

do k2 = 0 (không dịch chuyển) nên P(kt*[2]) = P(kt[2]) = [0,400) T2 = T1P(kt[1])* = [0,400)  [0,400) = [0, 160)

i = 3

kt[3]= B, P(kt[3]) = P(B) = [400, 800) ;

h3=1 => miền phân bố dịch phải với bƣớc dịch k3 = 1 thành miền phân bố của C hay P(kt[3]) dịch chuyển thành P(kt*[3]) = [800, 1000)

T3 = T2P(kt[3])* = [0, 160)  [0,400) = [128, 160) i = 4

kt[4]= A, P(kt[4]) = P(A) = [0, 400) ;

h4=0 => miền phân bố dịch trái với bƣớc dịch k4 = 1 thành miền phân bố của C hay P(kt[4]) dịch chuyển thành P(kt*[4]) = [800, 1000)

T4 = T3P(kt[4])* = [128, 160)  [800,1000) = [153.6 , 160) i =5

kt[5]= B, P(kt[5]) = P(B) = [400, 800);

h5=0 => miền phân bố dịch trái với bƣớc dịch k5 = 2 thành miền phân bố của C hay P(kt[5]) dịch chuyển thành P(kt*[5]) = [800, 1000)

T5 = T4P(kt[5])* = [153.6 , 160)  [800,1000) = [158.72 , 160)

Thuật toán giải mã thực hiện nhƣ sau:

i=1

Code[1] = code = 159 thuộc miền phân bố của ký tự A P(kt*[1]) = [0, 400)

h1 = 0 => dịch phải P(kt*[1]), bƣớc dịch là k1 = 2 thành P(kt[1]) = [800, 100) kt[1] là ký tự C (xác định kt[1] dựa vào P(kt[1]))

i=2

code[2] = P(kt*[1]) → code[1] = [0, 400) → 159 = 397.5 (dựa theo công thức 3.11) P(kt*[2]) = [0, 400) h2 = 1, dịch trái P(kt*[2]), bƣớc dịch là k2 = 0 thành P(kt[2]) = [0, 400) k[2] = A i=3 code[3] = P(kt*[2]) → code[2] = [0, 400) → 397.5 = 993.75 P(kt*[3]) = [800, 1000) h3 = 1, dịch trái P(kt*[3]), bƣớc dịch là k3 = 1 thành P(kt[3]) = [400, 800) k[3] = B i=4 code[4] = P(kt*[3]) → code[3] = [800, 1000) → 993.75 = 968.75 P(kt*[4]) = [800, 1000) h4 = 0, dịch phải P(kt*[4]), bƣớc dịch là k4 = 1 thành P(kt[4]) = [0,400) k[3] = A i=5 code[5] = P(kt*[4]) → code[4] = [800, 1000) → 968.75 = 843.75 P(kt*[5]) = [800, 1000) h5 = 0, dịch phải P(kt*[5]), bƣớc dịch là k5 = 2 thành P(kt[5]) = [400,800) k[5] = B

Kết hợp kết quả của từng bƣớc giải mã ta thu đƣợc bản rõ ban đầu là: CABAB

Đánh giá độ phức tạp của thuật toán trên:

1. Số các phƣơng án xây dựng miền phân bố của m ký tự với miền cơ sở [0, D) là:

2. Gọi độ dài của khóa K là u, số các phƣơng án xây dựng K là: mu 3. Gọi độ dài của H là v, số các phƣơng án xây dựng H là: 2v

Số các phƣơng án tạo khóa:

Nhận xét về độ bảo mật của phƣơng pháp đề xuất:

- Số các phƣơng án tạo khóa là rất lớn khó có thể dò tìm trong thời gian ngắn

- Vì bản rõ là một chuỗi các ký tự trong khi đó bản mã lại là một số thực, hình ảnh của bản rõ (các mẫu của bản rõ) không đƣợc thể hiện (lặp lại) trong bản mã nên việc tấn công theo phƣơng pháp thống kê đối với phƣơng pháp này sẽ gặp nhiều khó khăn.

- Phƣơng pháp này cũng rất nhạy cảm với bản rõ, trong mô hình nhị phân miền phân bố của các ký tự là cố định và việc tìm ra miền phân bố này cũng khá đơn giản do chỉ cần tìm ra giá trị p, hơn nữa trong mô hình này chỉ dùng một khóa nhị phân nên độ an toàn chƣa thật sự cao. Trong mô hình luận văn đề xuất miền phân bố của các ký tự là thay đổi theo từng bƣớc và phụ thuộc vào 3 yếu tố: ký tự hiện tại, khóa k và khóa h. Vì vậy độ bảo mật cũng đƣợc tăng cƣờng đáng kể.

Chƣơng 4. CÀI ĐẶT VÀ THỬ NGHIỆM

Tóm tắt chương: Để cài đặt được phương pháp mã hóa số học phải thao tác trên các số nguyên lớn. Trong chương này sẽ giới thiệu thư viện xử lý số nguyên lớn đã được đưa ra bởi các tác giả trong tài liệu [1]. Thư viện này được dùng để xây dựng phần mềm mã hoá dữ liệu theo phương pháp mã hóa số học truyền thống và phương pháp mã hóa số học cải tiến.Phần cuối chương là một số kết quả thử nghiệm của chương trình.

4.1. Giới thiệu thƣ viện xử lý số nguyên lớn

Hệ thống thƣ viện số nguyên lớn đƣợc tổ chức thành 2 lớp: Lớp hệ thập phân Nglon10 và lớp hệ 256 (gọi là lớp nhị phân) Nglon. Lớp NgLon10 cung cấp một số phƣơng thức nhập, xuất dữ liệu theo hệ 10 để giúp ngƣời dùng dễ dàng nhập dữ liệu hoặc theo dõi kết quả trung gian trong quá trình xử lý. Để giảm thời gian thực hiện trong các phép toán trên số nguyên lớn, lớp nhị phân lƣu trữ số nguyên lớn theo hệ số 256 (byte). Theo đó, mỗi chữ số của số nguyên lớn có thể đƣợc lƣu trữ trực tiếp trên thanh ghi và sử dụng trực tiếp các phép toán cơ bản đƣợc hỗ trợ bởi các bộ vi xử lý. Vì vậy, các phép toán thực hiện trên số nguyên lớn có tốc độ thực hiện nhanh hơn.

Lớp hệ thập phân NgLon10 có 18 phƣơng thức, lớp nhị phân NgLon có 38 phƣơng thức. Do khuôn khổ hạn chế, nên trong luận văn chỉ trình bày cách thức tổ chức dữ liệu của hệ thống thƣ viện và một số phƣơng thức có thuật toán phức tạp.

4.1.1. Cấu trúc của các lớp

class Nglon10 //lớp hệ thập phân { private: int n; char *a; public: //các phƣơng thức };

class Nglon //lớp hệ nhị phân { private: int m; BYTE *b; public: //các phƣơng thức };

Mỗi lớp gồm hai thuộc tính: Thuộc tính thứ nhất là một số nguyên lƣu trữ độ dài của số. Với số hệ thập phân là số chữ số hệ 10, còn số hệ nhị phân là số byte (thực chất là số chữ số trong hệ 256). Thuộc tính thứ hai là con trỏ trỏ tới vùng nhớ dùng để lƣu trữ các chữ số. Với số hệ thập phân, các chữ số có giá trị từ 0 đến 9, còn số hệ nhị phân các chữ số có giá trị từ 0 đến 255.

4.1.2. Bảng luỹ thừa 2 (bảng h)

Bảng h có kiểu Nglon10 dùng để lƣu trữ giá trị thập phân của 2i, trong đó: h[i].n chứa độ dài của giả trị 2i

h[i].a trỏ tới vùng nhớ chứa các chữ số của 2i Ví dụ:

Bảng 4.1 Dùng để lƣu trữ giá trị thập phân của 2i

Bảng h dùng đề chuyển đổi từ hệ thập phân sang hệ nhị phân và ngƣợc lại. Bảng này chiếm khá nhiều không gian bộ nhớ và nó quyết định độ dài của số nguyên trong hệ thống. Việc nghiên cứu cải tiến sự lƣu trữ của bảng trên có thể làm tăng độ dài của số nguyên trong hệ thống thƣ viên lên đến vài nghìn chữ số.

4.1.3. Sơ đồ hoạt động của hệ thống

Nhận xét: ngƣời sử dụng làm việc thông qua giao diện ở khối đầu tiên và khối cuối cùng, các khối còn lại là hộp đen do hệ thống tự động xử lý.

4.2. Thuật toán chuyển đổi

4.2.1. Thuật toán từ hệ thập phân sang hệ nhị phân

Input: x số thập phân kiểu NgLon10 Output:y số nhị phân kiểu NgLon

Thuật toán: Thuật toán dưới đây xác định các bit 1 của y 1.u =x;

2.Thực hiện lặp:

2.1. Duyệt trên bảng h tìm k nhỏ nhất sao cho: u < 2k+1

2.2. Gán bit thứ k của y bằng 1 (số thứ tự các bit tính từ 0)

2.3 u=u-2k//phép trừ ở đây là phép trừ thập phân 2.4 Nếu u > 0 trở lại bước 2.1.

Nếu u=0 kết thúc thuật toán.

Nhận xét. Để tăng tốc độ xử lý của thuật toán, khi cài đặt có thể áp dụng các thủ thuật sau:

- Do bảng h đã đƣợc sắp xếp nên trong bƣớc 2.1 có thể sử dụng tìm kiếm nhị phân để xác định k.

- Từ lần lặp thứ 2 trở đi, chỉ cần xét từ đầu bảng h đến giá trị 2k của lần lặp trƣớc đó. - Độ phức tạp thuật toán trong trƣờng hợp xấu nhất là log2x, tốt nhất là 1.

4.2.2. Thuật toán từ hệ nhị phân sang hệ thập phân

Input: y số nhị phân kiểu NgLon Output:x số thập phân kiểu NgLon10 Thuật toán:

1. x=0;

2. Thực hiện lặp:

2.1. Tìm bit cao nhất của y, gọi là k 2.2. x = x + 2k

// dùng bảng h và phép cộng thập phân 2.3. Xoá bit k của y //y = y-2k

2.4. Nếu y=0 kết thúc thuật toán Nếu y>0 trở lại bước 2.1

Độ phức tạp của thuật toán trong trƣờng hợp xấu nhất là log2y, tốt nhất là 1.

4.3. Thuât toán chia (div, mod)

Thuật toán đơn giản nhất khi thực hiện phép chia là qui về phép trừ, theo sơ đồ sau:

Input: p, q (p>=q)số nhị phân kiểu NgLon Ouput: div=p DIV q, mod=p MOD q

1. div = 0; 2. mod = p; 3. While (mod  q) { 3.1. mod = mod - q; 3.2. div = div + 1; }

Thuật toán này thực hiện chậm. Để cho phép chia hiệu quả, chúng tôi xây dựng thuật toán chia tựa nhƣ cách chia tự nhiên :

Input: p, q (p>=q)số nhị phân kiểu NgLon Ouput: div=p DIV q, mod=p MOD q

Thuật toán: Ký hiệu:

+ p[t]-số nguyên hệ nhị phân tạo bởi t bit cao của p. + u=sizeof(p) //độ dài theo bit

+ v=sizeof(q) //độ dài theo bit 1. Xác định S (trích phần đầu)

+ S=p[v] nếu p[v]>=q + S=p[v+1] nếu trái lại k=sizeof(S)

2. Đặt bít thứ u-k của div=1 3. Thay p[k] bằng p[k]-S

4. Nếu p>=q quay lại bước 1,trái lại kết thúc thuật toán

Kết quả: div đã xác định, mod=p.

Độ phức tạp của thuật toán trƣờng hợp xấu nhất bằng sizeof(p)-sizeof(q), tốt nhất bằng 1.

4.4. Thuật toán phân rã nhị phân tính luỹ thừa mod

Hiện đã có một số phƣơng pháp tính biểu thức lũy thừa mod:

trong đó phƣơng pháp bình phƣơng liên tiếp hay đƣợc sử dụng. Để hiểu rõ hơn về phƣơng pháp này ta xét trƣờng hợp m =13. Đầu tiên khai triển số mũ 13 theo hệ cơ số 2, tức là:

13 = 8 + 4 + 1 = 23 + 22 +20 (*)

Rồi tính tiếp các đồng dƣ bình phƣơng, nhƣ sau: a1 = a2 mod n

a2 = a12 mod n a3 = a22 mod n

Sau đó tổng hợp lại, căn cứ theo khai triển (*), lấy tích của các lũy thừa bậc 23

, 22, 20 sẽ thu đƣợc kết quả:

q = a3 * a2 *a0 (mod n)

Qua ví dụ trên có thể đánh giá độ phức tạp của thuật toán này nhƣ sau: Số phép nhân và số phép mod không vƣợt quá 2log2 m.

Trong báo cáo này sử dụng phƣơng pháp phân rã nhị phân. Với trƣờng hợp m = 13 thì phƣơng pháp đƣợc thực hiện nhƣ sau:

Đầu tiên sử dụng quá trình lặp để phân rã nhị phân số mũ m: 13 = 2*6 +1 (dƣ thừa 1)

6 = 2*3 + 0 (không dƣ thừa) 3 =2*1 + 1 (dƣ thừa 1)

Sau đó dùng quá trình lặp để tính giá trị biểu thức: a0 = a

a1 = a02 * a (mod n) a2 = a12 (mod n) a3 = a22 * a (mod n) q = a3

Qua ví dụ có thể thấy: số phép nhân không quá 2log2m , số phép mod bằng log2 m. Nhƣ vậy độ phức tạp của hai phƣơng là tƣơng đƣơng và đều có thời gian đa thức.

Phƣơng pháp này có thể cài đặt theo đệ quy hoặc tổ chức hai vòng lặp để phân rã số mũ và tính biểu thức. Khi cài đặt nên sử dụng phƣơng pháp lặp để giảm bộ nhớ và tăng tốc độ tính toán. Dạng đệ quy của thuật toán có thể đƣợc trình bày nhƣ sau:

Input: s, a, m, n Ouput: q = s.am mod n Thuật toán:

1.Nếu: m=1 thì q=s.a mod n

2.Nếu: m > 1, thực hiện các bước 2.1. Nếu m chẵn:

m1 = m/2

q = (s.am1 mod n)(am1 mod n) mod n 2.2. Nếu m lẻ:

m1 = (m-1)/2

q = (s.am1 mod n)(a.am1 mod n) mod n

4.5. Phƣơng pháp tính logarit

Cho x là giá trị có kiểu nguyên lớn, nên: x.m: độ dài theo byte của x x.b: dãy các byte của x (m byte) Gọi k là số bit có nghĩa, ta có:

k=(m-1)*8+size(x.b[m-1])

Nhƣ vậy x là số nhị phân độ dài k. Suy ra,

k k

x 2 2 1  

k-1  log2x < k Ví dụ 1: x.m=1 x.b=111 k=0+3=3 Suy ra, 2 3 2

2  x . Vậy log2x trong trƣờng hợp nay: 2  log2x < 3

Ví dụ 2: x.m=3 x.b= 000110101 | 01110011 | 00010101 k=16+5 Suy ra, 20 21 2

2 x . Vậy log2x trong trƣờng hợp nay: 20  log2x < 21 Nhƣ vậy để tính logarit thì thuật toán chỉ cần tính k theo công thức nhƣ trên. Độ phức tạp của thuât toán là hằng số.

4.6. Phƣơng pháp tính căn bậc hai

Sử dụng phƣơng pháp Newton để tính căn bậc hai, phƣơng pháp Newton là tìm cách thay phƣơng trình phi tuyến f(x)=0 đối với x, bằng phƣơng trìn gần đúng tuyến tính đối với x. y x x0 x1 x* y=f(x) 0 A B C α x* < x1 < x0

Chọn x0 > x* : CB = f(x0) AB = CB*tg(Cˆ) = f(x0)*f‟-1 (x0) x1= x0 - AB = x0 - f(x0)/f‟(x0) x1= x0 - f(x0)/f‟(x0) Tính x = u Xét phƣơng trình f(x) = x2 – u = 0 => f‟(x) = 2x Có công thức: xk+1 = xk - (xk 2 – u)/(2xk) <=> xk+1 = (xk 2 + u)/(2xk) = xk/2 +u/2xk

Với x0 = 2(k+1)/2 và u < 2k (u độ dài k bit) => u< 2k/2  2(k+1)/2 Trƣờng hợp x0 chẵn : x1= (x0 2 + u)/(2x0) = x0/2 + u/2x0 Trƣờng hợp x0 lẻ : x1= (x02 + u)/(2x0) = x0/2 + u/2x0 Vì x0 lẻ => x0 = 2t + 1 => x0/2 = (2t + 1)/2 = t + 1/2 = x1- u/2x0 x1= t + (x0 + u)/2x0

x1 ở đây chính là giá trị gần đúng của u

4.7. Kết quả thử nghiệm

Để cài đặt các thuật toán chúng tôi đã sử dụng kiểu nguyên lớn size byte (size≤200) từ [1], với size đƣợc chọn linh hoạt bởi ngƣời sử dụng (ở đây chọn size = 25). Bản rõ đƣợc chia thành các khối với độ dài 25-30 ký tự (ứng với size =25). Việc mã hóa đƣợc tiến hành theo từng khối. Chƣơng trình đƣợc viết bằng ngôn ngữ VC++ 6.0 cho thuật toán truyền thống và thuật toán cải tiến 3.4. Kết quả thử nghiệm dƣới đây cho thấy thuật toán cải tiến nhanh hơn khoảng 1000 lần so với thuật toán truyền thống.

Phép so sánh Độ dài bản rõ (ký tự) Số ký tự khác nhau

Thời gian mã hóa (Đơn vị tính toán 0.001 giây)

Thời gian giải mã (Đơn vị tính toán 0.001