Năm 1950, R.W.Hamming đã tạo ra mã Hamming và những cải tiến của mã Hamming vẫn được sử dụng cho đến ngày nay. Mã Hamming truyền m bit thông tin cùng với k bit chẵn lẻ. Chúng có khả năng sửa được 1 bit lỗi bất kì. Các bit chẵn lẻ được xếp vào các vị trí 1,2,…,2k-1 và kiểm tra các bit mà vị trí của chúng ở dạng nhị phân có giá trị 1 tại vị trí ki - 1. Ví dụ, bit chẵn lẻ ở vị trí K3= 4 sẽ kiểm tra các bit có vị trí là 100, 101, 110, 111, 1100, 1101,… = 4,5,6,7,12,13,…
Giả sử rằng chuỗi dữ liệu là 100110.Ta sẽ thêm vào chuỗi các bit chẵn lẻ tại các vị trí như sau k1k21k3001k410.
Bảng 2.2-1 Chuỗi dữ liệu sau khi được thêm vào các bit chẵn lẻ Thứ tự bit 1 2 3 4 5 6 7 8 9 10 Vị trí bit chẵn lẻ và bit dữ liệu K1 K2 1 K3 0 0 1 K4 1 0 K1 1 1 0 1 1
K2 0 1 0 1 0
K4 1 1 0 Chuỗi mã hóa 1 0 1 1 0 0 1 0 1 0
Vậy chuỗi bit được truyền đi là 1011001010. Giả sử chuỗi bị sai ở vị trí 5.Vậy chuỗi khi đó là 1011101010.Quá trình giải mã như sau
Bảng 2.2-2 Quá trình kiểm tra tính đúng đắn chuỗi dữ liệu Thứ tự bit 1 2 3 4 5 6 7 8 9 10 Kiểm tra
chẵn lẻ
Bit chẵn lẻ
Vị trí bit kiểm tra và bit dữ liệu K1 K2 1 K3 0 0 1 K4 1 0 Dữ liệu nhận được 1 0 1 1 1 0 1 0 1 0 K1 1 1 1 1 1 Sai 0 K2 0 1 0 1 0 Đúng 1 K3 1 1 0 1 Sai 0 K4 1 1 0 Đúng 1
Giá trị số nguyên các bit chẵn lẻ là 0101 = 5. Vậy bit sai ở vị trí 5. Kỹ thuật này hiệu quả hơn hẳn kỹ thuật lặp. Ta chỉ cần thêm vào logn bit thay vì xn, nhưng nó chỉ có thể sửa được 1 lỗi. Nếu 2 lỗi xảy ra, mã Hamming sẽ sửa ra một chuỗi sai.
2.2.4 Mã sửa lỗi Reed Solomon
Năm 1960, Irving Reed và Gus Solomon đã tạo ra một loại mã sửa lỗi - mã Reed Solomon. [4]
2.2.4.1 Trường hữu hạn
Khái niệm
Để hiểu được nguyên lý mã hóa và giải mã các mã không nhị phân, như mã Reed-Solomon (R-S), ta cần phải tìm hiểu khái niệm trường hữu hạn - Galois Field (GF). Cho một số nguyên tố p, sẽ tồn tại một trường hữu hạn, kí hiệu là GF(p) có p phần tử. Ta có thể mở rộng GF (p) thành pm phần tử, được gọi là trường mở rộng của GF(p), kí hiệu là GF(pm) với m là số nguyên dương. Chú ý
rằng GF(pm) chứa tập con của GF(p). Các kí hiệu (symbol) trong trường GF(2m
) được sử dụng trong việc xây dựng mã Reed-Solomon (R-S).
Trường nhị phân GF(2) là tập con của trường mở rộng GF(2m). Ngoài các số 0 và 1, còn có các phần tử duy nhất trong trường mở rộng GF(2m) được biểu diễn bằng kí hiệu α. Mỗi phần tử khác 0 trong GF(2m) được biểu diễn bằng lũy thừa của α. Một tập F vô hạn được cấu thành bằng việc bắt đầu với các phần tử {0, 1, α }, các phần tử tiếp theo được tạo ra bằng cách nhân phần tử cuối với α. Kết quả là:
F = {0, 1, α1 , α 2, …, α j, …} (2.1) Để thu được tập hữu hạn các phần tử của GF(2m) từ F, một điều kiện được đặt ra để nó chỉ có 2m phần tử là:
+ 1 = 0 hoặc tương đương
= 1 = α0
(2.2) Với điều kiện này, các phần tử có lũy thừa lớn hơn hoặc bằng 2m-1 có thể được rút gọn với lũy thừa nhỏ hơn 2m-1, như sau:
= α n+1= α n+1
(2.3)
Từ (2.2), ta có thể biểu diễn 1 tập hữu hạn F* từ tập vô hạn F như sau:
F* = { 0, 1, }
= { 0, } (2.4) Từ (2.4), ta có thể thấy được các phần tử hữu hạn của trường hữu hạn GF(2m):
GF(2m) = { 0, } (2.5)
Mỗi phần tử trong trường hữu hạn GF(2m) có thể được biểu diễn bằng một đa thức riêng biệt có bậc m -1 hoặc nhỏ hơn. Ta kí hiệu phần tử khác 0 trong GF(2m) là một đa thức ai(X), trong đó có tối thiểu một hệ số m khác 0. Với i = 0, 1, 2, …,2m
- 2 αi (adsbygoogle = window.adsbygoogle || []).push({});
= ai(X) = ai,0 + ai,1X + ai,2X2 + … + ai,m-1Xm-1 (2.6) Trường hợp m = 3, trường hữu hạn sẽ là GF(23). Hình 2.2-1 thể hiện việc ánh xạ 7 phần tử { αi } và phần tử 0 theo các phần tử cơ sở {X0
, X1, X2} như phương trình (2.6). Phương trình (2.2) cho biết α7= α0, do đó có 7 phần tử khác 0 hoặc có tất cả 8 phần tử trong trường này. Hình 2.2-1, một chuỗi giá trị nhị phân biểu diễn các hệ số ai,0, ai,1, ai,2 trong phương trình (2.6). Một trong những lợi ích của việc sử dụng các phần tử trường mở rộng là việc thay thế các phần tử nhị phân thành các kí hiệu nhỏ gọn tạo điều kiện cho các biểu diễn toán học của quá trình mã hóa và giải mã. Việc cộng hai phần tử trong trường hữu hạn được định nghĩa là tổng modul-2 của mỗi hệ số đa thức.
αi+αj
= (ai,0 + aj,0) + (ai,1+ aj,1) X + (ai,2 + aj,2) X2 + … + (ai,m-1+ aj,m-1) Xm-1
Bảng 2.2-3 Thể việc các phép toán cộng và nhân trong GF(8)
Phép cộng hai phần tử bất kì trong trường hữu hạn bằng cách cộng các hệ số tương ứng trong đa thức của chúng. Phép nhân của hai phần tử bằng cách cộng số mũ của chúng modul-(2m -1), trong trường hợp này là modul-7.
2.2.4.2 Mã Reed-Solomon
Khái niệm: Mã Reed-Solomon là mã vòng không nhị phân với một chuỗi các symbol m bit, trong đó m là một số nguyên dương lớn hơn 2. Mã R-S(n,
k) với các symbol m bit với
n = 2m - 1, k = 2m -1 - 2t
Trong đó k là số symbol dữ liệu hay số lượng thông tin được mã hóa, n là tổng số symbol gồm symbol dữ liệu và symbol kiểm tra, t là khả năng sửa lỗi của mã, và n - k = 2t là số lượng symbol kiểm tra.
Dữ liệu được truyền đi là lượng thông tin đã được mã hóa. Bộ mã hoá lấy k
symbol dữ liệu, mỗi symbol m bit, rồi thêm vào (n-k) symbol kiểm tra để tạo thành một từ mã n symbol. Sau khi nhận được, bộ mã hóa sẽ giải mã từ mã n symbol này để phục hồi lại thông tin ban đầu.
Một mã R-S(n, k) có khả năng sửa lỗi tối đa ⌊ ⌋ lỗi. Ngoài sửa lỗi, mã R-S còn có khả năng sửa sai các erasure (hiện tượng mất symbol). Các thủ tục mã hoá và giải mã R-S(n,k) có thể đảm bảo sửa được tối đa (n-k) erasure. Một cách tổng quát, một mã RS(n,k) có khả năng sửa được e lỗi và r erasure với điều kiện: 2e+r< (n– k).
Quá trình mã hóa
Đa thức sinh của mã R-S(n, k) có dạng như sau: g(X) = g0+ g1X+ g2X2 + … + g2t-1X2t-1 + X2t
Bậc của đa thức sinh bằng với số lượng symbol kiểm tra trong mã R-S. Vì đa thức sinh có bậc 2t, do đó sẽ có 2t lũy thừa của α - nghiệm của đa thức. Ta kí hiệu nghiệm của g(X) là α, α2, α3, …, α2t. Ví dụ, đa thức của mã R-S(7, 3) sinh có 2t = n - k = 4 nghiệm, được biểu diễn như sau:
g(X) = (X - ) (X - 2) (X - 3) (X - 4)
= ( X2 - ( + 2) X + 3) (X2 - ( 3 + 4) X + 7) = (X2 - 4X + 3) ( X2 - 6X + 0)
= X4 - ( 4 + 6)X3 + ( 3 + 10 + 0) X2 - ( 4 + 9) X + 3 = X4 - 3X3 + 0X2 - 1X + 3
Theo thứ tự từ thấp lên cao và thay dấu "-" thành dấu "+", vì trong trường nhị phân +1 = -1, g(X) được biểu diễn lại như sau:
g(X) = 3 + 1X + 0X2 + 3X3 + X4
Với dữ liệu ban đầu m(X), ta mã hóa dữ liệu bằng cách nhân m(X) với g(X) để tạo ra 1 từ mã (code word) U(X): U(X) = m(X) g(X)
Ví dụ: chuỗi dữ liệu 3-symbol, mỗi symbol có 3-bit 010 110 111 Ta có đa thức m(X) = 1 + 3X + 5X2 Ta được từ mã: U(X) a= m(X) g(X) (2.7) = ( 1 + 3X + 5X2) ( 3 + 1X + 0X2+ 3X3 + X4)
= 0 + 2X + 4X2 + 6X3 + 1X4 + 3X5 + 5X6
= (100) + (001) X + (011) X2 + (101)X3 + (010)X4 + (110)X5 + (111)X6 Với một từ mã bất kì, nghiệm của đa thức sinh chính là nghiệm của từ mã.
U( ) = U( 2) = U( 3) = U( 4) = 0 Thật vậy: U( ) = + + + + + + = + + + + + + = + + + = + = 0 U( ) = + + + + + + = + + + + + + = + + + = + = 0 U( ) = + + + + + + = + + + + + + = + + + = + = 0 U( ) = + + + + + + = + + + + + + = + + + = + = 0
Quá trình giải mã
Một thông điệp được mã hóa bằng cách sử dụng mã R-S (7, 3) để tạo ra từ mã được biểu diễn bởi (2.7). Giả sử trong quá trình truyền dữ liệu, từ mã bị làm hư sao cho 2 symbol nhận được bị lỗi ( đây là số lỗi tương ứng khả năng sửa lỗi tối đa của mã). Với từ mã 7-symbol, một đa thức lỗi được biểu diễn như sau:
∑ (adsbygoogle = window.adsbygoogle || []).push({});
Ví dụ, đa thức lỗi bị 2 lỗi trong quá trình truyền dữ liệu, 1 symbol kiểm tra và một symbol dữ liệu
e(X) = 0 + 0X + 0X2 + 2 X3 + 5X4 + 0X5 + 0X6
= (000) + (000)X + (000)X2 + (001)X3 + (111)X4 + (000)X5 + (000)X6
Đa thức từ bị lỗi nhận được r(X) được biểu diễn bằng tổng của đa thức từ được truyền đi và đa thức lỗi như sau:
r(X) = U(X) + e(X)
= (100) + (001) X + (011) X2 + (100)X3 + (101)X4 + (110)X5 + (111)X6 = 0 + 2X + 4X2 + 0X3 + 6X4 + 3X5 + 5X6 (2.9)
Trong ví dụ trên, có 4 ẩn số cần tìm: 2 giá trị lỗi và 2 vị trí lỗi. Có sự khác biệt quan trọng giữa giải mã nhị phân và không nhị phân. Trong giải mã nhị phân, bộ giải mã chỉ cần tìm vị trí lỗi và giá trị lỗi sẽ bị thay đổi từ 1 thành 0 và ngược lại. Nhưng ở đây, các symbol không nhị phân đòi hỏi không những tìm thấy vị trí lỗi mà còn phải xác định các giá trị đúng tại những vị trí đó. Vì có 4 ẩn số trong ví dụ này, do đó cần 4 phương trình để tìm ra 4 ẩn số này.
Tính Syndrome
Syndrome S là kết quả của việc kiểm tra r(X) để xác định r(X) có phải là từ mã hợp lệ hay không. Nếu đúng, syndrome phải bằng 0. Nếu tồn tại một giá trị của S khác 0, chứng tỏ có lỗi xuất hiện. Syndrome S có n - k symbol, {Si} (i = 1, … ,n - k). Như ta đã nói trong quá trình mã hóa
U(X) = m(X) g(X)
Ta thấy mỗi từ mã hợp lệ U(X) chia hết cho đa thức sinh g(X). Cho nên, nghiệm của g(X) cũng là nghiệm của U(X).Vì r(X) = U(X) + e(X), nếu các nghiệm của g(X) được thế vào r(X) chỉ cho ra kết quả bằng 0 thì r(X) là từ mã hợp lệ. Nếu có lỗi sẽ cho ra một hoặc nhiều kết quả khác 0.Việc tính toán một symbol syndrome được biểu diễn như sau:
|
Ví dụ, r(X) chứa 2 symbol lỗi như phương trình (2.9). Nếu r(X) là từ mã hợp lệ, mỗi symbol Si đều bằng 0. Ví dụ:
S1 = r( ) = + + + + + + = + + + + + + = S2 = r( ) = + + + + + + = + + + + + + = S3 = r( ) = + + + + + + = + + + + + + = S4 = r( ) = + + + + + + = + + + + + + =
Ta có:
| [ ]|
Si = r( ) = U( ) + e( ) = 0 + e( ) (2.10)
Từ (2.10) ta thấy giá trị syndrome bằng với giá trị của đa thức lỗi khi thế các nghiệm của g(X). Giả sử có v lỗi trong từ mã tại các vị trí , , …, . Khi đó đa thức lỗi e(X) trong phương trình (2.8) được viết lại như sau:
e(X) = + + … +
Để sửa từ mã bị lỗi, mỗi giá trị lỗi và vị trí lỗi của nó phải được xác định, trong đó l = 1, 2, …, v. Tiếp theo, ta tính n - k = 2t symbol syndrome bằng cách thay thế αi vào đa thức nhận với i = 1, 2, …, 2t:
S1 = r( ) = + + … + S2 = r( ) = + + … + ● ● ● S2t = r( ) = + + … +
Ta có 2t ẩn số ( t giá trị lỗi và t vị trí lỗi tương ứng), và 2t phương trình. Do đó ta có thể tìm ra nghiệm của phương trình. Bài báo cáo này không đi sâu chi tiết quá trình giải phương trình.
Từ các nghiệm tìm được ta xác định được đa thức lỗi e(X). Từ đó tính được từ mã hợp lệ. Phương trình (2.9)
r(X) = U(X) + e(X) => U(X) = r(X) - e(X)
Vì trong trường hữu hạn phép "-" là phép cộng "+", nên ta có
U(X) = r(X) + e(X)
Với từ mã hợp lệ này, ta có thể khôi phục lại dữ liệu ban đầu bằng phương trình
U(X) = r(X) g(X) (adsbygoogle = window.adsbygoogle || []).push({});
2.3 Tổng quan về mã hóa
Mã hóa và giải mã là một phần trong hệ thống đang hướng đến. Một số giải thuật mã hóa, giải mã cũng như là ưu nhược điểm của chúng sẽ được chúng tôi giới thiệu tiếp sau đây. Nội dung được trích lọc từ một tài liệu [5] và [6]
2.3.1 Tổng quan
Mã hóa (encryption) là phương pháp biến đổi dữ liệu ban đầu (plaintext) thành dạng dữ liệu không thể đọc được (ciphertext). Dữ liệu ban đầu là dữ liệu có thể đọc hiểu bởi con người hoặc là các dạng dữ liệu mà máy tính có thể hiểu và thực thi (executable code). Khi dữ liệu được mã hóa, cả người và máy đều không hiểu được cho đến khi nó được giải mã. Việc mã hóa những dữ liệu nhạy cảm khi lưu trữ chúng trên máy tính là việc làm cần thiết để tránh những truy cập của kẻ xấu. Đặc biệt, mã hóa rất cần thiết khi truyền tải dữ liệu qua mạng nhất là qua các kênh truyền không an toàn.
Hình 2.3-1 Mã hóa và giải mã
Một hệ thống hỗ trợ mã hóa và giải mã dữ liệu được gọi là một cryptosystem. Hệ thống này được xây dựng dựa trên phần cứng hoặc hỗ trợ thông qua code trong ứng dụng. Cryptosystem sử dụng các giải thuật mã hóa, các giải thuật này cho biết mức độ phức tạp của hệ thống. Hầu hết các giải thuật đều là những hàm toán học phức tạp được áp dụng trên plaintext. Các giải thuật mã hóa sử dụng một giá trị gọi là khóa (key), thường là một chuỗi bit, để mã hóa và giải mã (Hình 2.3-2).
Hình 2.3-2 Mã hóa
Giải thuật mã hóa là tập hợp các luật toán học phức tạp để mã hóa và giải mã dữ liệu. Hiện nay, cơ chế mà nhiều giải thuật làm việc không còn được giữ bí mật nữa. Phần bí mật của một quá trình mã hóa dữ liệu chính là khóa. Khóa là một giá trị bất kỳ được tạo nên từ một chuỗi lớn các bit ngẫu nhiên. Tuy nhiên không phải bất kỳ giá trị nào cũng có thể là khóa. Mỗi giải thuật sẽ có một miền giá trị nhất định (gọi là không gian khóa - keyspace), trong đó mỗi giá trị có thể làm khóa cho giải thuật đó. Keyspace càng lớn đồng nghĩa với việc tìm ra khóa chính xác mà giải thuật sử dụng cũng khó khăn hơn (hay nói cách khác là an toàn hơn).
2.3.1.1 Substitution Cipher - Transposition Cipher
Để chuyển một plaintext thành một ciphertext, có hai kỹ thuật cơ bản đó là thay thế (substitution cipher) và hoán vị (transposition cipher hay permutation cipher).
Phương pháp thay thế sẽ thay các bit, ký tự hoặc một nhóm ký tự bởi các bit, ký tự hoặc nhóm ký tự khác. Phương pháp hoán vị không thay thế các giá trị hiện tại bởi các giá trị khác mà nó dịch chuyển (hoán vị) các bit hay các ký tự với nhau nhằm tạo thành một dữ liệu mới.
Hình 2.3-3 Không gian khóa
Substitution Cipher
Kỹ thuật này sử dụng khóa để dẫn hướng cho quá trình thay thế. Trường hợp đơn giản nhất là giải thuật Caesar Cipher phát minh bởi Julius Caesar, mỗi ký tự được thay thế bởi một ký tự khác nằm ở vị trí thứ 3 ngay sau nó trong ký tự trong bảng chữ cái alphabet. Ví dụ,
plain: meet me after the toga party cipher: PHHW PH DIWHU WKH WRJD SDUWB
Ta có thể thấy rằng, Caesar Cipher rất yếu vì keyspace của Caesar Cipher chỉ gồm 25 giá trị. Tất nhiên, đây chỉ là ví dụ đơn giản cho phương pháp thay thế. Thực tế phương pháp này được sử dụng trong các giải thuật nhưng với sự phức tạp gấp nhiều lần, hơn nữa chúng thường sử dụng nhiều hơn một bảng chữ cái.
Như đã nói, phương pháp này sẽ hoán chuyển vị trí các ký tự trong mẫu ban đầu. Khóa sẽ được sử dụng để chỉ ra vị trí mà các ký tự được di chuyển tới.
Ví dụ, ta có thể sắp xếp các ký tự của plaintext thành một mảng nhiều dòng, sau đó hoán vị các cột và ghi lại theo thứ tự cột ta được ciphertext:
Key: 4 3 1 2 5 6 7 Plaintext: a t t a c k p o s t p o n e d u n t i l t w o a m x y z Ciphertext: TTNAAPTMTSUOAODWCOIXKNLYPETZ
Trên thực tế, việc các hoán chuyển vị trí này được xác định bởi những hàm toán học phức tạp hơn rất nhiều.
Hầu hết các giải thuật hiện nay sử dụng một chuỗi các thao tác thay thế và hoán vị phức tạp để chuyển plaintext thành ciphertext. Chuỗi thao tác này được một giải thuật tạo ra nhờ vào một giá trị khóa cụ thể.
2.3.1.2 Block Cipher - Stream Cipher
Block cipher mã hóa plaintext theo từng khối (block). Thường thì mỗi khối có kích thước khoảng 64 bit hoặc 128 bit. Các khối này được mã hóa một cách riêng biệt không phụ thuộc lẫn nhau cũng như trạng thái hiện tại của quá trình mã