Nhóm 12 - Xây dựng module HMAC-SHA-256 trên FPGA - Kíp 01.pdf

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG
KHOA KỸ THUẬT ĐIỆN TỬ 1
BÁO CÁO BÀI TẬP LỚN
MÔN HỌC: ĐỒ ÁN THIẾT KẾ HỆ THỐNG SỐ
Đề tài: Xây dựng module mã hóa HMAC-SHA-256
Giảng viên hướng dẫn : Nguyễn Văn Thành
Nhóm : 12
Thành viên : Nguyễn Đăng Khoa-B20DCDT110
: Lưu Việt Đức-B20DCDT054
Hà Nội - 2024

1
Mục lục
Danh mục hình ảnh...............................................................................................................2
Lời nói đầu............................................................................................................................3
Chương 1: Giới thiệu về FPGA............................................................................................4
1.1. Giới thiệu về FPGA....................................................................................................4
1.1.1. Giới thiệu .............................................................................................................4
1.1.2. Các bước thiết kế cho FPGA ...............................................................................6
1.1.3 Nguyên lý hoạt động.............................................................................................7
1.2. Giới thiệu về Module mã hóa HMAC-SHA-256......................................................8
1.2.1. Module mã hóa HMAC-SHA-256.......................................................................8
1.2.2. Cách module mã hóa HMAC-256 hoạt động ......................................................9
1.3. Giới thiệu Module mã hóa HMAC-SHA-256 trên kit FPGA..................................10
1.3.1. Tổng quan về module mã hóa HMAC-SHA-256 trên kit FPGA ......................10
1.3.2. Cài đặt và kiểm tra module mã hoá HMAC-256 trên FPGA..............................10
1.4 Kết luận chương: .......................................................................................................11
Chương 2: Cơ sở lý thuyết..................................................................................................12
2.1. Ngôn ngữ thiết kế phần cứng.....................................................................................12
2.1.1. Verilog................................................................................................................12
2.1.2. VHDL.................................................................................................................14
2.2. Các phần mềm ứng dụng..........................................................................................16
2.2.1. Vivado................................................................................................................16
2.2.2. Quartus...............................................................................................................18
2.3 Mã hóa HMAC- SHA-256........................................................................................20
2.3.1. Khái niệm mã hóa SMAC-SHA-256.................................................................20
2.4. Kết luận chương ......................................................................................................29
Tài liệu tham khảo ..............................................................................................................31

2
Danh mục hình ảnh
STT Tên hình ảnh Trang
1 Kiến trúc của FPGA 4
2
Sơ đồ khối cấu trúc của một chương trình
Verilog
13
3
Sơ đồ khối cấu trúc chương trình
VHDL
16
4
Sơ đồ khối quá trình thiết kế mức hệ thống
trong Vivado
17

3
Lời nói đầu
Trong thế giới ngày nay, bảo mật thông tin trở thành một yếu tố không thể phủ
nhận đối với mọi hệ thống. Với sự phát triển không ngừng của công nghệ, việc xác
định và bảo vệ thông tin quan trọng trở nên ngày càng cần thiết. Trong bối cảnh đó,
việc sử dụng mã hóa là một trong những biện pháp hiệu quả nhất để đảm bảo tính bí
mật và toàn vẹn của dữ liệu.
Trong đề tài này, chúng ta sẽ đi sâu vào việc xây dựng một module mã hóa sử
dụng thuật toán HMAC-SHA-256. HMAC (Hash-based Message Authentication
Code) là một phương pháp mã hóa chống giả mạo dựa trên hàm băm, kết hợp với một
khóa bí mật, để tạo ra một mã xác thực dựa trên thông điệp và khóa. SHA-256 là một
trong những hàm băm phổ biến và an toàn, được sử dụng rộng rãi trong nhiều ứng
dụng bảo mật.
Chúng ta sẽ tìm hiểu cách triển khai và sử dụng HMAC-SHA-256 để mã hóa
và xác thực dữ liệu trong các ứng dụng thực tế. Bằng cách nắm vững cơ chế hoạt
động của HMAC-SHA-256, chúng ta có thể xây dựng các hệ thống bảo mật vững
chắc, đáng tin cậy trước những mối đe dọa mạng ngày càng phức tạp. Hãy cùng nhau
khám phá và áp dụng kiến thức này vào thực tế để tạo ra những giải pháp bảo mật
hiệu quả và tiên tiến hơn.

4
Chương 1: Giới thiệu về FPGA
Mục tiêu chương là:
+ Cung cấp một cái nhìn tổng quan về FPGA: Chương trình này mục tiêu giúp người
đọc hiểu về FPGA, từ các khái niệm cơ bản đến cách hoạt động và ứng dụng trong
lĩnh vực kỹ thuật điện tử.
+ Giới thiệu nguyên lý hoạt động cơ bản của FPGA: Chương trình này sẽ giải thích
kiến trúc của FPGA để giúp người đọc hiểu cách FPGA được lập trình để thực hiện
các chức năng logic và xử lý dữ liệu.
+ Trình bày về ứng dụng của FPGA: Chương trình này sẽ mô tả các lĩnh vực ứng
dụng chính của FPGA như mạng viễn thông, hệ thống nhúng, xử lý tín hiệu số, trí
tuệ nhân tạo và nhiều lĩnh vực khác. Người đọc sẽ hiểu được tiềm năng và lợi ích của
FPGA trong việc xây dựng các hệ thống phức tạp và linh hoạt.
1.1. Giới thiệu về FPGA
1.1.1. Giới thiệu
FPGA (Field-Programmable Gate Array) là một loại vi mạch tích hợp có khả
năng lập trình được. Nó cho phép người sử dụng tạo ra các mạch logic và chức năng
tùy chỉnh mà không cần thay đổi phần cứng. FPGA linh hoạt, dễ dàng thay đổi và
phát triển, và được sử dụng rộng rãi trong các lĩnh vực như điện tử tiêu dùng, mạng
viễn thông, xử lý tín hiệu, điều khiển và tự động hóa.
FPGA là sự kết hợp giữa thời gian hoàn thành sản phẩm và khả năng điều
khiển được của PLD với mật đọ và ưu thế về chỉ phí của GateArray.
Hình 1. Kiến trúc của FPGA

5
Kiến trúc của FPGA bao gồm:
• Logic Array Block (LAB): Đây là thành phần cơ bản của FPGA, nơi thực
hiện các chức năng logic và xử lý dữ liệu
• Look-Up Tables (LUTs): LUTs là một phần của LC, các LUTs được sử dụng
để thực hiện các hàm logic đơn giản, như AND, OR, NOT, và cũng có thể
được kết hợp để tạo ra các hàm logic phức tạp hơn.
• Interconnect: là mạng lưới các đường dẫn được sử dụng để kết nối các ô lý
logic, bộ nhớ chương trình và các thành phần khác trên chip.
• I/O Blocks: FPGA cung cấp các khối đầu vào/đầu ra (I/O blocks) để kết nối
với các thiết bị ngoại vi hoặc hệ thống bên ngoài. Các khối này có thể hỗ trợ
các chuẩn giao tiếp như GPIO,UART,SPI,I2C,Ethernet, và nhiều chuẩn khác
• Block RAM: Block RAM là các khối bộ nhớ được tích hợp trên FPGA, được
sử dụng để lưu trữ dữ liệu trong các ứng dụng đòi hỏi bộ nhớ lớn.
• DSP Blocks: Các khối DSP là các khối chức năng đặc biệt được tối ưu hóa
để thực hiện các phép toán số học nhanh chóng và phức tạp, phổ biến trong
xử lý tín hiệu
Các loại FPGA:
Dựa trên thiết kế phần cứng bên trong của các khối, FPGA có thể được phân
loại thành ba loại:
• Mạng sắp xếp (Mesh-based FPGA): Loại FPGA này sử dụng một mạng lưới
2D của các ô logic được kết nối với nhau. Mỗi ô logic có thể truy cập trực
tiếp đến các ô lân cận trong mạng, tạo ra một cấu trúc mạng linh hoạt cho
việc định tuyến tín hiệu. Mạng sắp xếp giúp tối ưu hóa định tuyến và đạt
được hiệu suất cao.
• Mạng chuyển mạch (Switch-based FPGA): Loại FPGA này sử dụng một
mạng chuyển mạch để kết nối các ô logic. Các mạng chuyển mạch cho phép
các tín hiệu được chuyển từ một ô logic đến ô logic khác thông qua các kết
nối điểm-to-điểm. Mạng chuyển mạch thường có cấu trúc phức tạp hơn so
với mạng sắp xếp, nhưng cung cấp tính linh hoạt và khả năng định tuyến cao
hơn.
• Mạng hỗn hợp (Hybrid FPGA): Loại FPGA này sử dụng một sự kết hợp giữa
mạng sắp xếp và mạng chuyển mạch để tận dụng lợi ích của cả hai. Các ô
logic được tổ chức thành một mạng sắp xếp hoặc mạng chuyển mạch, tùy

6
thuộc vào yêu cầu và đặc điểm của ứng dụng. Mạng hỗn hợp cung cấp sự
linh hoạt và hiệu suất cao, giúp đáp ứng các yêu cầu phức tạp của các ứng
dụng FPGA.
Dựa trên loại công nghệ lập trình, FPGA có thể được phân thành ba loại:
• SRAM-Based FPGA: Đây là loại FPGA phổ biến nhất và được sử dụng rộng
rãi. Các ô logic và kết nối trong SRAM-Based FPGA được lập trình bằng
cách lưu trữ các bit trong các ô bộ nhớ SRAM. Điều này cho phép tái lập
trình và thay đổi cấu hình FPGA một cách linh hoạt, nhưng yêu cầu việc cấp
nguồn liên tục để duy trì cấu hình.
• Antifuse-Based FPGA: Chúng sử dụng công nghệ CMOS chống sử dụng và
một khi FPGA đã được lập trình, nó không thể được lập trình lại. Họ giữ lại
chương trình của họ khi tắt nguồn.
• Flash-Based FPGA: Loại FPGA này sử dụng ô nhớ flash để lưu trữ cấu hình
và lập trình. Cấu hình FPGA có thể được lưu trữ và duy trì mà không cần
nguồn điện liên tục. Flash-Based FPGA cung cấp khả năng tái lập trình,
nhưng có thời gian khởi động lâu hơn và số lần tái lập trình giới hạn so với
SRAM-Based FPGA.
• EEPROM-Based FPGA: Loại FPGA này sử dụng ô nhớ EEPROM
(Electrically Erasable Programmable Read-Only Memory) để lưu trữ cấu
hình. EEPROM- Based FPGA cung cấp tính năng tái lập trình và có thể duy
trì cấu hình mà không cần nguồn điện duy trì. Tuy nhiên, chúng có thời gian
khởi động và khả năng tái lập trình chậm hơn so với SRAM-Based FPGA.
1.1.2. Các bước thiết kế cho FPGA
Bước 1: Design Entry:
Nhập thiết kế theo sơ đô nguyên lý Schemaric: Bước này bao gồm chuyển đổi
ý tưởng thiết kế thành một dạng biểu diễn máy tính. Điều này thường được thực hiện
bằng cách sử dụng ngôn ngữ mô tả phần cứng (HDL). Hai HDL phổ biến nhất là
Verilog và Very High Speed Integrated Circuit HDL (VHDL)
Bước 2: Kiềm tra thiết kế (Design Verification)
Thực hiện kiểm tra, mô phỏng chức năng hoạt động của thiết kế HDL đã
tạo ra ở trên. Bước này có thể không cần phải thực hiện trong khi thiết kế.
Bước 3: Tổng hợp thiết kế (Design Synthesis)
Công cụ tổng hợp nhận được HDL sau đó sẽ lựa chọn nhà sản xuất và mô hình
FPGA. Từ hai thông tin này, nó tạo ra một netlist sử dụng các phần tử logic được đề
xuất bởi nhà cung cấp để đáp ứng các logic behavior được chỉ định trong các tệp

7
HDL. Kết quả của netlist này là bản chỉnh sửa và tối ưu hóa từ thiết kế HDL
Bước 4: Thực hiện thiết kế (Design Implementation)
Bước này sử dụng file Netlist và file ràng buộc “constrains file” (mô tả các
nguyên tắc thiết kế, các ràng buộc về vật lý như gán vị trí cho các đầu vào/ra trên
chip, các ràng buộc về tốc độ, thời gian, tần số...), bộ đặt lấy netlist tổng hợp và chọn
một vị trí cho mỗi phần tử logic bên trong chip. Nhiệm vụ của bộ định tuyến sau đó
là kết nối tất cả các nguyên tố này với nhau để đáp ứng các ràng buộc
Bước 5: Mô phỏng định thời (Timing Simulation)
Sau bước thực hiện thiết kế,người thiết kế có thể thực hiện mô phỏng thiết kế
ở mức cồng logic đã được định vị trí và định tuyến trên FPGA để thực hiện kiểm tra
hoạt động của thiết kế mà có tính đến các tham số thời gian trễ, thời gian thiết lập...
của các công logic trong FPGA. Bước này. rất quan trong với những. thiết kế phức
tạp, tốc độ lớn.
Bước 6: Cấu hình (Configuration)
Gọi chương trình điều khiển việc nạp cấu hình, thực hiện kết nối thiết bị nạp
đến FPGA và nạp file cầu hình cho FPGA. Khác với CPLD, FPGA có thêm bước
“Creat Bit file” để tạo ra file “luồng bit” để nạp vào bộ nhớ cầu hình trong FPGA
thường là bộ nhớ tạm như SRAM.
1.1.3 Nguyên lý hoạt động
Một chip FPGA được thiết kế với một mạng lưới các ô logic được kết nối với
nhau. Mỗi ô logic bao gồm các cổng logic, bộ chuyển đổi đầu vào/đầu ra và các bộ
đếm, bộ nhớ và bộ xử lý phức tạp hơn có thể tích hợp vào trong các ô logic. Các ô
logic được kết nối với nhau bằng các đường dây liên kết gọi là interconnects, có thể
được cấu hình để tạo thành các mạch logic tuỳ ý. Mỗi FPGA cũng có các ô đầu vào
và đầu ra, cho phép nó giao tiếp với các linh kiện khác trong một hệ thống số.
Để sử dụng mạch logic mong muốn, người sử dụng cần lập trình một bản thể
hiện của nó vào FPGA bằng một ngôn ngữ mô tả phần cứng (Hardware Description
Language
- HDL) như Verilog hoặc VHDL. Sau khi được lập trình, FPGA sẽ được cấu hình
bằng một tập lệnh được gọi là bitstream, là một chuỗi các bit đại diện cho các liên
kết giữa các ô logic và các giá trị được lưu trữ trong các ô bộ nhớ.
Sau khi FPGA đã được cấu hình, nó có thể thực thi các chức năng logic được
thiết kế cho nó. Các FPGA thường được sử dụng trong các ứng dụng như xử lý tín
hiệu, mã hóa và giải mã video, và trong các hệ thống điều khiển nhúng. Vì FPGA có
khả năng tái cấu hình, chúng cũng thường được sử dụng trong các mô hình thử

8
nghiệm và các ứng dụng nghiên cứu để đo lường hiệu suất của các mạch logic mới.
Trong các ứng dụng mã hóa, FPGA có thể được sử dụng để thực hiện các
thuật toán mã hóa như AES, RSA và SHA-2. Nhờ tính linh hoạt và khả năng tùy
chỉnh của nó, FPGA cho phép các nhà phát triển thiết kế mạch mã hóa tùy chỉnh với
hiệu suất cao và độ chính xác tối ưu hóa cho ứng dụng cụ thể.
Việc sử dụng FPGA trong các ứng dụng mã hóa mang lại nhiều ưu điểm so
với các giải pháp phần cứng mã hóa truyền thống. FPGA có thể được cấu hình để
thực hiện nhiều loại thuật toán mã hóa và các tính năng bảo mật khác, cho phép chúng
được sử dụng trong nhiều ứng dụng khác nhau. Bên cạnh đó, FPGA có thể được tùy
chỉnh để phù hợp với yêu cầu hiệu suất cụ thể, đồng thời tiết kiệm chi phí và không
gian vật lý so với các giải pháp phần cứng mã hóa truyền thống.
1.2. Giới thiệu về Module mã hóa HMAC-SHA-256
1.2.1. Module mã hóa HMAC-SHA-256
Module mã hóa HMAC-256 là một thành phần phổ biến được sử dụng trong lập
trình để tạo và xác thực chữ ký số (digital signatures) hoặc mã băm (hash) dựa trên một
hàm băm (hash function) và một khóa bí mật (secret key)
Mã HMAC-256 được tạo bằng cách kết hợp dữ liệu đầu vào với khóa bí mật và sau
đó áp dụng hàm băm SHA-256 cho kết quả. Quá trình này đảm bảo tính toàn vẹn và xác
thực của dữ liệu, bằng cách kiểm tra xem liệu dữ liệu đã được thay đổi hay không.

9
1.2.2. Cách module mã hóa HMAC-256 hoạt động
Cách module mã hóa HMAC-SHA-256 hoạt động:
• Hàm băm SHA-256:
Module bắt đầu bằng việc sử dụng hàm băm SHA-256 để tạo ra một mã băm từ dữ liệu đầu
vào.
SHA-256 hoạt động bằng cách chia dữ liệu đầu vào thành các khối cố định và sau đó xử lý
từng khối lần lượt để tạo ra mã băm đầu ra.
Mã băm đầu ra có độ dài cố định là 256 bit, bất kể kích thước của dữ liệu đầu vào.
• Thêm khóa bí mật:
Sau khi có mã băm từ dữ liệu đầu vào, module sẽ thêm vào một khóa bí mật. Khóa bí mật
này có thể được tạo ra trước và được biết đến bởi cả người gửi và người nhận.
Mục đích của việc thêm khóa bí mật là tăng cường tính bảo mật của mã xác thực, đảm bảo
rằng người nhận chỉ có thể xác thực dữ liệu nếu họ biết được cả dữ liệu và khóa bí mật.
• Tạo mã HMAC:
Module sẽ sử dụng hàm băm SHA-256 một lần nữa để tạo ra mã xác thực cuối cùng, được
gọi là mã HMAC.

10
Quá trình này bao gồm việc kết hợp mã băm từ dữ liệu đầu vào và khóa bí mật, sau đó áp
dụng hàm băm SHA-256 lên kết quả để tạo ra mã HMAC.
Module mã hóa HMAC-SHA-256 thường được tích hợp vào các ứng dụng bảo mật và mạng
như xác thực giao tiếp mạng, chữ ký số và bảo mật dữ liệu. Nó cung cấp một cơ chế hiệu
quả và an toàn để đảm bảo tính bảo mật của thông tin trong môi trường mạng nguy hiểm.
Module mã hóa HMAC-256 thường được tích hợp sẵn trong các ngôn ngữ lập trình như
Python, Java, C++, và nhiều ngôn ngữ khác, làm cho việc sử dụng nó dễ dàng và tiện lợi
cho việc bảo mật dữ liệu trong ứng dụng.
1.3. Giới thiệu Module mã hóa HMAC-SHA-256 trên kit FPGA
1.3.1. Tổng quan về module mã hóa HMAC-SHA-256 trên kit FPGA
Module mã hóa HMAC-256 được triển khai trên các kit FPGA(Field-Programmable
Gate Array), cung cấp một giải pháp phần cứng để thực hiện các tính toán mã hóa một cách
hiệu quả và nhanh chóng. Việc triển khai trên FPGA mang lại nhiều lợi ích như tính linh
hoạt, hiệu suất cao và khả năng tùy chỉnh.
Điểm quan trọng về việc triển khai module mã hóa HMAC-256 trên kit FPGA:
• Tính tùy chỉnh: FPGA cho phép phát triển các thiết kế phần cứng tùy chỉnh cho các ứng
dụng cụ thể. Điều này có nghĩa là bạn có thể tối ưu hóa việc triển khai của mã HMAC-
256 để phù hợp với yêu cầu cụ thể của ứng dụng hoặc môi trường.
• Hiệu suất: FPGA có thể cung cấp hiệu suất tính toán cao và thời gian phản hồi nhanh.
Bằng cách sử dụng phần cứng đặc biệt được lập trình cho tính toán HMAC-256, bạn có
thể đạt được tốc độ xử lý đáng kể so với việc triển khai mã hóa dựa trên phần mềm.
• Bảo mật: Sử dụng FPGA có thể cung cấp một cấp độ bảo mật cao hơn so với triển khai
phần mềm, vì mã được thực thi trực tiếp trên phần cứng và không dễ dàng bị tấn công
từ bên ngoài.
• Tiết kiệm tài nguyên: FPGA cung cấp khả năng tái cấu hình và sử dụng tài nguyên phần
cứng một cách linh hoạt. Bạn có thể tích hợp mã HMAC-256 vào một hệ thống lớn hơn
trên cùng một chip FPGA mà không cần sử dụng nhiều tài nguyên.
• Dễ dàng tích hợp: Các module mã hóa HMAC-256 có thể được tích hợp vào các thiết
kế FPGA một cách dễ dàng thông qua sử dụng các ngôn ngữ mô tả phần cứng như
Verilog hoặc VHDL.
1.3.2. Cài đặt và kiểm tra module mã hoá HMAC-256 trên FPGA
Các bước cần thiết để cài đặt và kiểm tra module là:
• Thiết lập môi trường Vivado: Bắt đầu bằng việc cài đặt và thiết lập môi trường làm việc
Vivado của Xilinx để sử dụng các công cụ và tài nguyên của FPGA.

11
• Tạo project: Mở Vivado và khởi tạo một project mới. Trong quá trình tạo project, chọn
board FPGA phù hợp để triển khai module mã hóa HMAC-SHA-256.
• Thêm các khối mã hóa HMAC-SHA-256 vào project: Trong project mới, thêm các khối
mã hóa HMAC-SHA-256 vào dự án. Đây có thể là một IP core hoặc một mô-đun mã
hóa được cung cấp bởi bên thứ ba hoặc tự thiết kế.
• Kết nối các tín hiệu: Kết nối các tín hiệu điều khiển và dữ liệu giữa các khối mã hóa
HMAC-SHA-256 và các thành phần khác trên FPGA, bao gồm cả bộ nhớ và các giao
tiếp khác nếu cần.
• Thiết lập các tham số: Thiết lập các tham số cần thiết cho module mã hóa HMAC-SHA-
256, bao gồm chiều dài của khóa, dữ liệu đầu vào, và các tham số khác có thể cần thiết.
• Tạo bitstream: Sau khi thiết lập xong các tham số, sử dụng Vivado để tổ chức dự án và
tạo bitstream, là file chứa các hướng dẫn logic cần thiết để cấu hình FPGA.
• Kiểm tra module: Cuối cùng, thực hiện các bước kiểm tra để đảm bảo rằng module mã
hóa HMAC-SHA-256 hoạt động đúng và đáp ứng các yêu cầu của quá trình mã hóa.
Các bước kiểm tra bao gồm kiểm tra chức năng, hiệu suất và tính bảo mật của module.
1.4 Kết luận chương:
Chương 1 nhằm giới thiệu tổng quan về FPGA. Qua chương này, độc giả sẽ
hiểu về cấu trúc các thành phần bên trong,nguyên tắc hoạt động,quy trình thiết kế
FPGA.
Chương này nhấn mạnh tiềm năng của chip FPGA trong việc phát triển các hệ
thống điện tử phức tạp và linh hoạt. Bằng cách hoàn thành chương này, độc giả sẽ
có kiến thức căn bản về FPGA và có khả năng đánh giá khả năng ứng dụng của nó
trong các dự án điện tử.
Chương này cũng giới thiệu về module mã hóa HMAC-SHA-256 và cách triển khai
nó trên kit FPGA. HMAC-SHA-256 sử dụng thuật toán băm SHA-256 để tạo mã HMAC,
một công cụ quan trọng trong việc xác thực và bảo mật dữ liệu. SHA-256 tạo ra chữ ký 256
bit từ dữ liệu đầu vào, và được sử dụng rộng rãi trong các ứng dụng như tạo chữ ký số, bảo
mật blockchain và kiểm tra phiên bản phần mềm.
Module mã hóa HMAC-SHA-256 thường được triển khai trên kit FPGA để cung
cấp hiệu suất cao, tính linh hoạt và bảo mật trong việc thực hiện các tính toán mã hóa. Cài
đặt và kiểm tra module trên FPGA đòi hỏi các bước như thiết lập môi trường Vivado, tạo
project, thêm các khối mã hóa vào dự án, kết nối các tín hiệu, thiết lập các tham số, tạo
bitstream và kiểm tra module để đảm bảo tính đúng đắn và hiệu suất.
Việc triển khai module mã hóa HMAC-SHA-256 trên FPGA mang lại nhiều lợi ích
như tính tùy chỉnh, hiệu suất cao, bảo mật và dễ dàng tích hợp vào các thiết kế phức tạp.

12
Chương 2: Cơ sở lý thuyết
Mục tiêu chương:
Giới thiệu về phần mềm Vivado: Chương này giới thiệu cơ bản về phần mềm
Vivado của Xilinx. Người đọc sẽ nắm được tổng quan về giao diện và các chức năng
chính của Vivado, bao gồm công cụ synthesis, placement, routing và bitstream
generation.
Giới thiệu về ngôn ngữ VHDL-Verilog: Chương này giới thiệu về ngôn ngữ
VHDL- Verilog. Người đọc sẽ nắm được ưu và nhược điểm, cấu trúc của 1 chương
trình trong VHDL.
2.1. Ngôn ngữ thiết kế phần cứng
2.1.1. Verilog
+ Tổng quan về Verilog
Verilog là một ngôn ngữ mô phỏng phần cứng được sử dụng trong thiết kế và
mô hình hóa logic kỹ thuật số. Nó được sử dụng phổ biến trong việc thiết kế vi mạch
tùy chỉnh (FPGA) và IC (Integrated Circuits). Verilog có hai phiên bản chính là
Verilog-1995 và Verilog-2001, với Verilog-2001 hỗ trợ các tính năng mở rộng và
nâng cao hơn.
Cú pháp của Verilog dựa trên ngôn ngữ C và rất giống với VHDL (VHSIC
Hardware Description Language). Ngôn ngữ này cho phép mô hình hóa và mô tả các
thành phần phần cứng như bộ đếm, bộ chuyển đổi, bộ nhớ, và các mạch logic khác.
Verilog có thể được sử dụng để mô hình hóa một hệ thống hoặc một mạch
logic cụ thể bằng cách sử dụng một tập hợp các mô-đun (module) và mô tả các tín
hiệu và luồng dữ liệu bên trong các mô-đun đó. Các mô-đun có thể được kết hợp và
tương tác với nhau để tạo ra một hệ thống logic hoàn chỉnh.
Verilog thường được sử dụng trong các ứng dụng sau:
− Thiết kế vi mạch tùy chỉnh (FPGA và IC)
− Mô phỏng logic kỹ thuật số
− Xác minh và kiểm tra phần cứng
− Mô hình hóa hệ thống
− Xác minh phần mềm nhúng
+ Ưu điểm của ngôn ngữ Verilog
Mạnh mẽ và linh hoạt: Verilog cung cấp cú pháp mạnh mẽ và linh hoạt, cho
phép mô hình hóa mọi mức độ phức tạp của mạch logic số, từ các cổng đơn giản đến
các thành phần phức tạp như vi mạch tử điển (FPGA) hay vi mạch tích hợp (ASIC).
Thiết kế hiệu năng cao: Verilog cho phép tối ưu hóa hiệu năng của mạch logic.

13
Người dùng có thể tùy chỉnh và điều chỉnh các mô hình Verilog để tối ưu hóa tốc
độ, diện tích và tiêu thụ năng lượng của mạch logic.
Tích hợp dễ dàng: Verilog có khả năng tích hợp tốt với các công cụ và quy
trình thiết kế phổ biến khác. Nó có thể được sử dụng kết hợp với các công cụ tổng
hợp, mô phỏng, xác minh và xác định thời gian để tạo ra mạch logic đáng tin cậy và
hiệu quả.
Sự phổ biến và hỗ trợ cộng đồng: Verilog là một ngôn ngữ phổ biến trong lĩnh
vực thiết kế vi mạch. Do đó, có một cộng đồng rộng lớn của các kỹ sư và nhà nghiên
cứu sẵn sàng chia sẻ kiến thức, kinh nghiệm và tài liệu liên quan đến Verilog.
+ Cấu trúc của một chương trình Verilog
Hình 2. Sơ đồ khối cấu trúc của một chương trình Verilog
Trong sơ đồ trên, mô-đun chính là nơi định nghĩa chương trình Verilog. Nó
bao gồm các thành phần chính như khai báo tín hiệu, khối mã chức năng, cấu trúc
điều khiển, gán giá trị, đồng bộ/không đồng bộ và xử lý sự kiện.
− Khai báo tín hiệu: Định nghĩa các tín hiệu đầu vào và đầu ra cần thiết cho
chương trình Verilog.

14
− Khối mã chức năng: Định nghĩa các chức năng và logic của chương trình.
− Cấu trúc điều khiển: Sử dụng các cấu trúc điều khiển như if-else, case, for,
while để kiểm soát luồng đi của chương trình.
− Gán giá trị: Gán giá trị cho các tín hiệu và biến trong chương trình.
− Đồng bộ/không đồng bộ: Đồng bộ hoặc không đồng bộ các tín hiệu trong
chương trình dựa trên xung đồng hồ.
Xử lý sự kiện (Event-driven): Xử lý các sự kiện xảy ra trong chương trình,
chẳng hạn như thay đổi trạng thái của tín hiệu.
2.1.2. VHDL
+ Tổng quan về VHDL
VHDL (VHSIC Hardware Description Language) là một ngôn ngữ mô tả phần
cứng được sử dụng rộng rãi trong ngành công nghiệp điện tử để mô hình hóa, thiết
kế và kiểm tra mạch logic số. Được đưa vào sử dụng từ những năm 1980, VHDL đã
trở thành một tiêu chuẩn quốc tế (IEEE Standard 1076) và được hỗ trợ bởi nhiều
công cụ và môi trường phần mềm EDA (Electronic Design Automation).
VHDL cho phép mô tả cấu trúc và hành vi của phần cứng số thông qua việc
sử dụng khối logic, tín hiệu và cấu trúc điều khiển. Ngôn ngữ này hỗ trợ mô tả từ
mức trừu tượng cao đến mức trừu tượng thấp, cho phép mô hình hóa từ mô-đun và
chức năng đến cấu trúc chi tiết như cổng và flip-flop. Điều này cho phép nhà thiết
kế mô tả và kiểm tra phần cứng trước khi triển khai nó trên một nền tảng phần cứng
thực tế.
Hiện nay 2 ứng dụng chính và trực tiếp của VHDL là các ứng dụng trong các
thiết bị logic có thể lập trình được (Programmable Logic Devices –PLD) (bao gồm
các thiết bị logic phức tạp có thể lập trình được và các FPGA -Field Programmable
Gate Arrays) và ứng dụng trong ASICs(Application Specific Integrated Circuits).
+ Ưu điểm của VHDL
VHDL (VHSIC Hardware Description Language) có nhiều ưu điểm đáng chú
ý, giúp nó trở thành một ngôn ngữ phổ biến trong thiết kế phần cứng. Dưới đây là
một số ưu điểm của VHDL:
− Mô tả phần cứng: VHDL cho phép mô tả chi tiết các thành phần phần
cứng và cách chúng tương tác với nhau. Điều này giúp trong việc thiết
kế và mô hình hóa hệ thống phức tạp.
− Tính tái sử dụng cao: VHDL cho phép tạo ra các tạo ra các khối logic
đã được kiểm tra và xác minh tính đúng đắn và sử dụng lại chúng trong

15
các dự án khác
− Kiểm tra và mô phỏng: VHDL cho phép viết các bộ kiểm tra (testbench)
để kiểm tra và xác minh tính đúng đắn của mạch logic. Điều này giúp
giảm thiểu rủi ro lỗi và tăng độ tin cậy của mạch trước khi triển khai nó
trên phần cứng thực tế
− Hỗ trợ công cụ EDA: VHDL là một phần của quy trình thiết kế hỗ trợ
bởi nhiều công cụ và môi trường phần mềm EDA (Electronic Design
Automation) như Xilinx Vivado, Quartus II, ModelSim và Synopsys
Design Compiler
− Tối ưu hóa: VHDL cho phép tối ưu hóa thiết kế để đạt hiệu suất tốt hơn
và tiết kiệm tài nguyên trên FPGA.
+ Cấu trúc của chương trình VHDL
Tất cả các chương trình VHDL bao gồm ít nhất ba thành phần cơ bản sau đây:
− Khai báo thư viện (LIBRARY): Trong phần này, ta khai báo các thư viện cần
sử dụng trong chương trình VHDL.
− ENTITY (thực thể): Ở phần này, ta định nghĩa entity, tức là khai báo các giao
diện (ports) của mạch. Entity mô tả các tín hiệu vào (inputs) và tín hiệu ra
(outputs) của mạch logic/
− ARCHITECTURE (kiến trúc): Trong phần này, ta mô tả cách hoạt động của
mạch logic bên trong entity. Ta sử dụng cấu trúc các component, process,
signal, và các câu lệnh để mô tả chức năng của mạch logic.

16
Hình 3. Sơ đồ khối cấu trúc chương trình VHDL
2.2. Các phần mềm ứng dụng
2.2.1. Vivado
Phần mềm Vivado Design Suite cung cấp một loạt các giải pháp để thực hiện
các nhiệm vụ liên quan đến thiết kế và kiểm tra FPGA. Ngoài quá trình thiết kế RTL-
to- bitstream, Vivado Design Suite tập trung vào tích hợp hệ thống và thiết kế IP
(intellectual property). Các IP khác nhau có thể dễ dàng được cấu hình và kết nối
thành các khối hệ thống IP trong môi trường IP integrator của Vivado. Vivado cung
cấp các thư viện IP sẵn có cho các khối IP và IP tùy chỉnh có thể được cấu hình, đóng
gói và tạo sẵn từ catalog IP của Vivado.
Quá trình thiết kế cho phép kiểm tra và phân tích ở mỗi giai đoạn. Các tính
năng thiết kế bao gồm mô phỏng logic, I/O và clock, phân tích nguồn, xác định ràng
buộc và phân tích thời gian, kiểm tra giá trị thiết kế (DRC), mô phỏng và thay đổi
giá trị thiết kế logic, và lập trình và gỡ lỗi. Vivado Design Suite cung cấp một công
cụ toàn diện để hỗ trợ người dùng trong quá trình thiết kế và kiểm tra chip FPGA.

17
Hình 4. Sơ đồ khối quá trình thiết kế mức hệ thống trong Vivado
Vivado Design Suite hỗ trợ các thiết kế chuẩn công nghiệp sau:
• Tcl
• AXI4, IP-XACT
• Synopsys design constraints (SDC)
• Verilog, VHDL, SystemVerilog
• SystemC, C, C++, OpenCL
Các tính năng chính trong quá trình thiết kế:
• Vivado synthesis: được sử dụng để biến đổi mô tả phần cứng được viết
bằng ngôn ngữ mô tả phần cứng như VHDL hoặc Verilog thành một
netlist tương ứng
• Vivado implementation: quá trình Vivado Implementation bao gồm các
giai đoạn placement (đặt chỗ) và routing (định tuyến) để xác định vị trí
vật lý của các thành phần logic trên FPGA và thiết lập các đường dẫn
kết nối giữa chúng.
• Vivado timing analysis: phân tích và đưa ra kết qua để kết luận xem tín
hiệu trong mạch thiết kế đáp ứng các yêu cầu về độ trễ và đồng bộ hóa
theo các rằng buộc được xác định
• Vivado power analysis: được sử dụng để phân tích và đánh giá tiêu thụ
công suất trong một thiết kế FPGA
• Bitstream generation: là một tập tin nhị phân chứa các thông tin cấu
hình cần thiết để lập trình và hoạt động FPGA theo thiết kế đã được xác
định trước.

18
Các tính năng trên đóng góp vào việc tăng cường hiệu suất, đảm bảo được sự
chính xác trong thiết kế và tiết kiệm thời gian trong quá trình thiết kế hệ thống số
và logic programable.
Một số công cụ trong Vivado:
− Xilinx Software Development Kit (SDK) : phát triển phần mềm dựa
trên phần cứng đã được thiết kế hoàn chỉnh.
− Xilinx System Generator tool: thiết kế và triển khai hệ thống xử lý tín
hiệu số (DSP) bằng cách sử dụng môi trường đồ họa cấp cao.
− C-based High-Level Synthesis (HLS) tool: giúp ánh xạ trực tiếp các
khối chức năng và các hàm được viết bằng ngôn ngữ C/C++ và ánh xạ
trực tiếp vào phần cứng logic.
− Vivado IDE cung cấp 1 môi trường cấu hình chân I/O cho phép phân
bổ các cổng I/O lên trên các chân thiết bị đóng gói chỉ định.Nó được
thực hiện thông qua bước tạo một Constraints File (XDC) và sử dụng
các tài liệu hỗ trợ của Xilinx như Pin Planning, I/O Planning, và
Package Files.
2.2.2. Quartus
Quartus II là công cụ phần mềm phát triển của hãng Altera, cung cấp môi trường
thiết kế toàn diện cho các thiết kế SOPC (hệ thống trên 1 chip khả trình - system on a
programmable chip).
Đây là phần mềm đóng gói tích hợp đầy đủ phục vụ cho thiết kế logic với các linh
kiện logic khả trình PLD của Altera, gồm các dòng APEX, Cyclone, FLEX, MAX,
Stratix… Quartus cung cấp các khả năng thiết kế logic sau:
• Môi trường thiết kế gồm các bản vẽ, sơ đồ khối, công cụ soạn thảo các ngôn ngữ:AHDL,
VHDL, và Verilog HDL.
• Thiết kế LogicLock.
• Là công cụ mạnh để tổng hợp logic.
• Khả năng mô phỏng chức năng và thời gian.
• Phân tích thời gian.
• Phân tích logic nhúng với công cụ phân tích SignalTap@ II.
• Cho phép xuất, tạo và kết nối các file nguồn để tạo ra các file chương trình.
• Tự động định vị lỗi.
• Khả năng lập trình và nhận diện linh kiện.
• Phần mềm Quartus II sử dụng bộ tích hợp NativeLink@ với các công cụ thiết kế cung

19
cấp việc truyền thông tin liền mạch giữa Quartus với các công cụ thiết kế phần cứng
EDA khác.
• Quartus II cũng có thể đọc các file mạch (netlist) EDIF chuẩn, VHDL và Verilog HDL
cũng như tạo ra các file netlist này.
• Quartus II có môi trường thiết kế đồ họa giúp nhà thiết kế dễ dàng viết mã, biên dịch,
soát lỗi, mô phỏng...
Với Quartus có thể kết hợp nhiều kiểu file trong 1 dự án thiết kế phân cấp. Có thể
dùng bộ công cụ tạo sơ đồ khối (Quartus Block Editor) để tạo ra sơ đồ khối mô tả thiết kế
ở mức cao, sau đó dùng các sơ đồ khối khác, các bản vẽ như: AHDL Text Design Files
(.tdf), EDIF Input Files (.edf), VHDL Design Files (.vhd), and Verilog HDL Design Files
(.v) để tạo ra thành phần thiết kế mức thấp.
Quartus II cho phép làm việc với nhiều file ở cùng thời điểm, soạn thảo file thiết kế
trong khi vẫn có thể biên dịch hay chạy mô phỏng các dự án khác. Công cụ biên dịch
Quartus II nằm ở trung tâm hệ thống, cung cấp quy trình thiết kế mạnh cho phép tùy biến
để đạt được thiết kế tối ưu trong dự án. Công cụ định vị lỗi tự động và các bản tin cảnh báo
khiến việc phát hiện và sửa lỗi trở nên đơn giản hơn
Các tính năng chính của Quartus:
• Thiết kế Logic: Quartus cung cấp một giao diện đồ họa cho phép người dùng thiết kế
logic và các chức năng trên FPGA thông qua sử dụng các khối logic, bộ nhớ, và các
phần tử khác được cung cấp.
• Tích hợp công cụ Synthesis và Place-and-Route: Quartus bao gồm các công cụ tổng hợp
(synthesis) và định vị đường đi (place-and-route) để tự động tạo ra mạch logic được cấu
hình cho FPGA từ một mô tả logic ở mức trừu tượng cao.
• Mô phỏng và Debugging: Quartus cung cấp môi trường mô phỏng cho phép người dùng
kiểm tra và debug mạch logic trước khi triển khai trên FPGA thực tế. Điều này giúp
giảm thời gian phát triển và đảm bảo tính đúng đắn của dự án.
• Tích hợp với FPGAs của Intel: Quartus hỗ trợ nhiều dòng chip FPGA của Intel, cho
phép người dùng dễ dàng triển khai dự án lên các kit phát triển và các mô-đun FPGA
của họ.
• Hỗ trợ Ngôn ngữ Mô tả Phần cứng: Quartus cho phép sử dụng ngôn ngữ mô tả phần
cứng như Verilog và VHDL để mô tả mạch logic. Điều này cho phép người dùng linh
hoạt trong việc thiết kế và mô tả logic.
• Tích hợp Công cụ Tiến trình: Quartus tích hợp nhiều công cụ hỗ trợ quản lý quy trình
thiết kế như version control, quản lý bản vá, và quản lý tài nguyên.

20
Quartus II hỗ trợ các chuẩn thiết kế
• Verilog,VHDL
• Ngôn ngữ Schematic và Block Diagram
• Công cụ Synthesis và Optimization
• Công nghệ Place-and-Route
• Mô phỏng và Debugging
• Công cụ Timing Analysis
• Tích hợp với Các Dòng Chip FPGA của Intet
2.3 Mã hóa HMAC- SHA-256
2.3.1. Khái niệm mã hóa SMAC-SHA-256
HMAC là viết tắt của "Hash-based Message Authentication Code" (Mã Xác thực
Tin nhắn Dựa trên Băm). HMAC - 256 sử dụng hàm băm SHA-256 (Secure HashAlgorithm
256-bit) để tạo mã HMAC. SHA-2 (Thuật toán băm an toàn 2), trong đó SHA-256 là một
trong những thuật toán băm phổ biến nhất hiện nay. Hàm băm mật mã, còn thường được
gọi là “thông báo”, “dấu vân tay” hoặc “chữ ký”, là một chuỗi ký tự gần như hoàn toàn độc
đáo được tạo từ một đoạn văn bản đầu vào riêng biệt. SHA-256 tạo chữ ký 256 bit (32
byte).
Ví dụ ta băm từ “hello” được:
2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
+ SHA-256 là gì?
SHA-256 là hàm băm tiêu chuẩn, vì vậy câu hỏi thực sự là “hàm băm là gì”?
Hàm băm mật mã tạo ra “dấu vân tay” của chuỗi đầu vào. Ví dụ: nếu chúng ta băm
toàn bộ văn bản trong bộ truyện “Chúa tể của những chiếc nhẫn” của JRR Tolkien bằng
thuật toán SHA 256, chúng ta sẽ nhận được đầu ra 256-bit duy nhất cho văn bản của cuốn

21
sách đó. Nếu chúng ta thay đổi dù chỉ một chữ cái trong cuốn sách, hàm băm đầu ra sẽ rất
khác.
Cần lưu ý rằng đầu ra của hàm băm là “gần như duy nhất” vì có số lượng chuỗi đầu ra hữu
hạn . Xét cho cùng, đầu ra của SHA-256 luôn dài 256 bit, nghĩa là nó có kích thước cố định.
Tuy nhiên, số lượng đầu vào có thể là vô hạn , nghĩa là một số đầu vào sẽ băm thành cùng
một đầu ra. Khi điều này xảy ra, nó được gọi là “va chạm” và gần như không thể xảy ra.
SHA-256 có 2^256 có thể có kết quả đầu ra. Con số đó là:
115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,58
4,007,913,129,639,936 kết quả
Ba mục đích chính của hàm băm là:
- Để xáo trộn dữ liệu một cách xác định
- Để chấp nhận đầu vào có độ dài tùy ý và xuất ra kết quả có độ dài cố định
- Để thao tác dữ liệu không thể đảo ngược. Đầu vào không thể được lấy từ đầu ra
SHA-256 hữu ích trong rất nhiều trường hợp! Đây là hàm băm nhanh và an toàn, đây là
một số cách phổ biến nhất được sử dụng:
• Để tạo sơ đồ xác thực trang web, sử dụng JWT, HMAC và MAC
• Để tạo chữ ký số
• Để bảo mật các chuỗi khối như Bitcoin và Ethereum
• Trong phần mềm chống vi-rút, để so sánh dấu vân tay của tập tin và chương trình
Trong các hệ thống kiểm soát phiên bản như Git để kiểm tra xem dữ liệu có thay đổi không
+ SHA-256 có an toàn không?
SHA-2 được biết đến nhờ tính bảo mật (nó chưa bị hỏng như SHA-1) và tốc độ của
nó. Trong trường hợp không tạo được khóa, chẳng hạn như khai thác Bitcoin bằng bằng
chứng công việc, thuật toán băm nhanh như SHA-2 thường chiếm thế thượng phong. SHA-
256 được định nghĩa chính thức trong FIPS 180-4 của Viện Tiêu chuẩn và Công nghệ Quốc
gia. Cùng với việc tiêu chuẩn hóa và chính thức hóa còn có một danh sách các vectơ kiểm
tra cho phép các nhà phát triển đảm bảo rằng họ đã triển khai thuật toán đúng cách. Kể từ
năm 2022, SHA-256 rất an toàn để sử dụng trong các ứng dụng của bạn.
2.3.2. Thuật toán
Chúng ta hãy xem từng bước một ví dụ về thuật toán băm SHA-256 bằng tay.

22
BƯỚC 1 - XỬ LÝ TRƯỚC
Chuyển đổi “hello world” sang nhị phân:
Nối thêm 1 đơn:
Pad bằng 0 cho đến khi dữ liệu là bội số của 512, ít hơn 64 bit (trong trường hợp là 448
bit):
Nối 64 bit vào cuối, trong đó 64 bit là số nguyên lớn đại diện cho độ dài của đầu vào ban
đầu ở dạng nhị phân. Trong trường hợp của chúng tôi, 88 hoặc ở dạng nhị phân, “1011000”.
Bây giờ chúng ta đã có dữ liệu đầu vào, giá trị này sẽ luôn chia hết cho 512.
BƯỚC 2 - KHỞI TẠO GIÁ TRỊ BĂM (H)
Bây giờ chúng tôi tạo 8 giá trị băm. Đây là các hằng số được mã hóa cứng biểu thị 32 bit
đầu tiên của các phần phân số của căn bậc hai của 8 số nguyên tố đầu tiên: 2, 3, 5, 7, 11,
13, 17, 19

23
BƯỚC 3 - KHỞI TẠO HẰNG SỐ TRÒN (K)
Tương tự như bước 2, chúng ta đang tạo một số hằng số. Lần này, có 64 người trong số họ.
Mỗi giá trị (0-63) là 32 bit đầu tiên của các phần phân số của căn bậc ba của 64 số nguyên
tố đầu tiên (2 - 311).
BƯỚC 4 - VÒNG LẶP CHUNK
Các bước sau đây sẽ xảy ra đối với mỗi “khối” dữ liệu 512 bit từ đầu vào của chúng tôi.
Trong trường hợp này, vì “hello world” quá ngắn nên sẽ chỉ có một đoạn. Ở mỗi lần lặp
của vòng lặp, chúng ta sẽ thay đổi các giá trị băm h0-h7, đây sẽ là đầu ra cuối cùng.
BƯỚC 5 - TẠO LỊCH NHẮN TIN (W)
Sao chép dữ liệu đầu vào từ bước 1 vào một mảng mới trong đó mỗi mục nhập là một từ
32 bit:

24
Thêm 48 từ nữa được khởi tạo bằng 0, như vậy chúng ta có một mảng w [0…63]
Sửa đổi các chỉ mục 0 ở cuối mảng bằng thuật toán sau:
Đối với tôi từ w [16…63]:
s0 = (w[i-15] xoay phải 7) xor (w[i-15] xoay phải 18) xor (w[i-15] dịch phải 3)
s1 = (w [i- 2] xoay phải 17) xor (w [i- 2] xoay phải 19) xor (w [i- 2] dịch phải 10)
w[i] = w[i-16] + s0 + w[i-7] + s1
Hãy làm w [16] để chúng ta có thể thấy nó hoạt động như thế nào:

25
Điều này để lại cho chúng tôi 64 từ trong lịch trình tin nhắn của chúng tôi (w):

26
BƯỚC 6 - NÉN
Khởi tạo các biến a, b, c, d, e, f, g, h và đặt chúng bằng giá trị băm hiện tại tương ứng. h0,
h1, h2, h3, h4, h5, h6, h7
Chạy vòng nén. Vòng lặp nén sẽ thay đổi các giá trị của a…h . Vòng nén như sau:
cho tôi từ 0 đến 63
S1 = (e xoay phải 6) xor (e xoay phải 11) xor (e xoay phải 25)
ch = (e và f) xor ((không phải e) và g)
temp1 = h + S1 + ch + k[i] + w[i]
S0 = (a xoay phải 2) xor (a xoay phải 13) xor (a xoay phải 22)
maj = (a và b) xor (a và c) xor (b và c)
temp2 := S0 + lớn
h = g

27
g = f
f = e
e = d + temp1
d = c
c = b
b = một
a = temp1 + temp2
Hãy cùng thực hiện lần lặp đầu tiên, tất cả phép cộng được tính theo modulo 2^32 :
a = 0x6a09e667 = 01101010000010011110011001100111
b = 0xbb67ae85 = 10111011011001111010111010000101
c = 0x3c6ef372 = 00111100011011101111001101110010
d = 0xa54ff53a = 10100101010011111111010100111010
e = 0x510e527f = 01010001000011100101001001111111
f = 0x9b05688c = 10011011000001010110100010001100
g = 0x1f83d9ab = 00011111100000111101100110101011
h = 0x5be0cd19 = 01011011111000001100110100011001
e rightrotate 6:
01010001000011100101001001111111 -> 11111101010001000011100101001001
e rightrotate 11:
01010001000011100101001001111111 -> 01001111111010100010000111001010
e rightrotate 25:
01010001000011100101001001111111 -> 10000111001010010011111110101000
S1 = 11111101010001000011100101001001 XOR
01001111111010100010000111001010 XOR 10000111001010010011111110101000
S1 = 00110101100001110010011100101011
e and f:
01010001000011100101001001111111
& 10011011000001010110100010001100 =
00010001000001000100000000001100
Not e:
01010001000011100101001001111111 -> 10101110111100011010110110000000
(not e) and g:
10101110111100011010110110000000
& 00011111100000111101100110101011 =
00001110100000011000100110000000
ch = (e and f) xor ((not e) and g)
= 00010001000001000100000000001100 xor 00001110100000011000100110000000
= 00011111100001011100100110001100
// k[i] is the round constant
// w[i] is the batch
temp1 = h + S1 + ch + k[i] + w[i]
temp1=01011011111000001100110100011001 + 00110101100001110010011100101011

28
+ 00011111100001011100100110001100 + 01000010100010100010111110011000 +
01101000011001010110110001101100
temp1 = 01011011110111010101100111010100
a rightrotate 2:
01101010000010011110011001100111 -> 11011010100000100111100110011001
a rightrotate 13:
01101010000010011110011001100111 -> 00110011001110110101000001001111
a rightrotate 22:
01101010000010011110011001100111 -> 00100111100110011001110110101000
S0 = 11011010100000100111100110011001 XOR
00110011001110110101000001001111 XOR 00100111100110011001110110101000
S0 = 11001110001000001011010001111110
a and b:
01101010000010011110011001100111
& 10111011011001111010111010000101 =
00101010000000011010011000000101
a and c:
01101010000010011110011001100111
& 00111100011011101111001101110010 =
00101000000010001110001001100010
b and c:
10111011011001111010111010000101
& 00111100011011101111001101110010 =
00111000011001101010001000000000
maj = (a and b) xor (a and c) xor (b and c)
= 00101010000000011010011000000101 xor 00101000000010001110001001100010
xor 00111000011001101010001000000000
= 00111010011011111110011001100111
temp2 = S0 + maj
= 11001110001000001011010001111110 + 00111010011011111110011001100111
= 00001000100100001001101011100101
h = 00011111100000111101100110101011
g = 10011011000001010110100010001100
f = 01010001000011100101001001111111
e = 10100101010011111111010100111010 + 01011011110111010101100111010100
= 00000001001011010100111100001110
d = 00111100011011101111001101110010
c = 10111011011001111010111010000101
b = 01101010000010011110011001100111

29
a = 01011011110111010101100111010100 + 00001000100100001001101011100101
= 01100100011011011111010010111001
Toàn bộ phép tính đó được thực hiện thêm 63 lần nữa, sửa đổi các biến trong suốt.
Chúng tôi sẽ không làm điều đó bằng tay nhưng chúng tôi sẽ kết thúc với:
h0 = 6A09E667 = 01101010000010011110011001100111
h1 = BB67AE85 = 10111011011001111010111010000101
h2 = 3C6EF372 = 00111100011011101111001101110010
h3 = A54FF53A = 10100101010011111111010100111010
h4 = 510E527F = 01010001000011100101001001111111
h5 = 9B05688C = 10011011000001010110100010001100
h6 = 1F83D9AB = 00011111100000111101100110101011
h7 = 5BE0CD19 = 01011011111000001100110100011001
a = 4F434152 = 01001111010000110100000101010010
b = D7E58F83 = 11010111111001011000111110000011
c = 68BF5F65 = 01101000101111110101111101100101
d = 352DB6C0 = 00110101001011011011011011000000
e = 73769D64 = 01110011011101101001110101100100
f = DF4E1862 = 11011111010011100001100001100010
g = 71051E01 = 01110001000001010001111000000001
h = 870F00D0 = 10000111000011110000000011010000
BƯỚC 7 - SỬA ĐỔI GIÁ TRỊ CUỐI CÙNG
Sau vòng lặp nén, nhưng vẫn trong vòng lặp chunk , ta sửa đổi các giá trị băm bằng cách
thêm các biến tương ứng vào chúng, à. Như thường lệ, mọi phép cộng đều có modulo 2^32.
BƯỚC 8 - GHÉP HÀM BĂM CUỐI CÙNG
Cuối cùng nhưng không kém phần quan trọng, hãy ghép tất cả chúng lại với nhau, nối chuỗi
đơn giản là đủ.
digest = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
=
B94D27B9934D3E08A52E52D7DA7DABFAC484EFE37A5380EE9088F7ACE2EFCE9

30
2.4. Kết luận chương
Chương 2 đã giới thiệu về phần mềm Vivado và ngôn ngữ VHDL-Verilog
trong việc thiết kế hệ thống FPGA. Chương này đã trình bày các khái niệm cơ bản
về Vivado và giới thiệu về ngôn ngữ VHDL-Verilog để mô hình hóa hệ thống.
Sau khi hoàn thành chương này, người đọc sẽ có kiến thức và kỹ năng cần
thiết để sử dụng phần mềm Vivado và ngôn ngữ VHDL-Verilog trong quy trình
thiết kế trên FPGA.

31
Tài liệu tham khảo
[1] "RFC 2104 - HMAC: Keyed-Hashing for Message Authentication" - Tài liệu
chính thức định nghĩa thuật toán HMAC. Đây là tài liệu cơ bản để hiểu rõ cơ chế
hoạt động của HMAC.
[2] "RFC 4868 - Using HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512
with IPsec" - Mô tả cách sử dụng HMAC-SHA-256 trong môi trường IPsec (Internet
Protocol Security), cung cấp thông tin chi tiết về việc triển khai và sử dụng trong các
ứng dụng cụ thể.
[3] "Cryptography and Network Security: Principles and Practice" của William
Stallings - Sách này cung cấp kiến thức sâu rộng về bảo mật mạng và mật mã, bao
gồm cả các phương pháp mã hóa và xác thực như HMAC-SHA-256.
[4] "Python Cryptography Toolkit (PyCrypto)" - Thư viện mã nguồn mở cung cấp
các công cụ và hàm cho việc triển khai HMAC-SHA-256 trong Python. Tài liệu và
ví dụ trong thư viện này có thể hữu ích cho việc hiểu và thực hành.
[5] "Java Cryptography Architecture (JCA)" - Tài liệu chính thức về kiến trúc mã
hóa trong Java, bao gồm cả cách sử dụng HMAC-SHA-256. Đây là tài liệu quan
trọng cho việc triển khai trong môi trường Java.
[6] "Secure Hash Standard (SHS)" của National Institute of Standards and
Technology (NIST) - Tài liệu chính thức về tiêu chuẩn băm an toàn, bao gồm cả
SHA-256. Đây là tài liệu cơ bản để hiểu về hàm băm được sử dụng trong HMAC-
SHA-256.

Nhóm 12 - Xây dựng module HMAC-SHA-256 trên FPGA - Kíp 01.pdf

More Related Content

Similar to Nhóm 12 - Xây dựng module HMAC-SHA-256 trên FPGA - Kíp 01.pdf (20)

Nhóm 12 - Xây dựng module HMAC-SHA-256 trên FPGA - Kíp 01.pdf