- Giải quyết bài toán ủy quyền phi tập trung: Chữ ký số cho phép chủ tài khoản chứng minh quyền sở hữu tài sản và phê duyệt chuyển tiền tới toàn thể mạng lưới mà không bao giờ phải tiết lộ Khóa bí mật (Private Key).
- Đường cong Elliptic secp256k1: Cả Bitcoin và Ethereum đều lựa chọn chuẩn đường cong \(y^2 = x^3 + 7 \pmod p\), mang lại độ bảo mật tương đương khóa RSA 3072-bit nhưng kích thước khóa chỉ vỏn vẹn 256 bits (32 bytes).
- Phép nhân vô hướng một chiều: Từ Private Key \(d\) có thể dễ dàng tính ra Public Key \(Q = d \cdot G\) trong vài micro-giây, nhưng việc giải ngược lại để tìm \(d\) khi biết \(Q\) vấp phải bài toán Logarit rời rạc (ECDLP) bất khả thi về mặt tính toán.
- Quy trình ký và xác thực ECDSA: Người gửi tạo ra cặp chữ ký \((r, s)\). Bất kỳ máy trạm nào trên thế giới cũng có thể dùng Public Key \(Q\) và nội dung giao dịch để kiểm tra tính hợp lệ trong thời gian \(O(1)\).
- Cạm bẫy bảo mật kinh điển - Tái sử dụng Nonce: Nếu lập trình viên để lộ hoặc tái sử dụng giá trị ngẫu nhiên \(k\) trong hai lần ký khác nhau, bất kỳ ai cũng có thể giải phương trình đại số để khôi phục hoàn toàn Private Key. Tiêu chuẩn RFC 6979 là giải pháp bắt buộc.
Trong các hệ thống tài chính truyền thống, quyền chuyển tiền của bạn được bảo vệ bằng tên đăng nhập, mật khẩu và mã OTP gửi qua SMS. Tuy nhiên, toàn bộ cơ chế này dựa trên một tiền đề bắt buộc: ngân hàng trung ương nắm giữ cơ sở dữ liệu xác thực danh tính của bạn. Khi bạn gửi yêu cầu, máy chủ ngân hàng kiểm tra mật khẩu trong cơ sở dữ liệu nội bộ và quyết định cho phép giao dịch diễn ra.
Nhưng trong một mạng lưới chuỗi khối phi tập trung toàn cầu như Bitcoin hay Ethereum, không có bất kỳ ngân hàng hay máy chủ trung tâm nào tồn tại. Làm thế nào một nút mạng xa lạ tại Tokyo có thể tin chắc rằng giao dịch chuyển 5 BTC từ ví của bạn sang một ví khác thực sự do chính bạn phê duyệt chứ không phải do một hacker mạo danh phát tán?
Câu trả lời chính là Mật mã học khóa bất đối xứng (Asymmetric Cryptography) và Thuật toán Chữ ký số trên đường cong Elliptic (ECDSA - Elliptic Curve Digital Signature Algorithm). Đây là công nghệ bảo đảm tính xác thực, tính toàn vẹn và tính chống chối bỏ (Non-repudiation) cho mọi dòng tiền luân chuyển trên Web3.
1. Mật mã học khóa đối xứng vs Khóa bất đối xứng
Để thấy được bước tiến mang tính cách mạng của chữ ký số, chúng ta cần phân biệt hai trường phái mật mã học:
Mật mã học đối xứng (Symmetric Cryptography)
Các thuật toán đối xứng (như AES-256, DES, ChaCha20) sử dụng cùng một khóa bí mật duy nhất cho cả quá trình mã hóa và giải mã.
- Điểm mạnh: Tốc độ xử lý cực nhanh, phù hợp mã hóa các luồng dữ liệu lớn (video call, tệp tin ổ đĩa).
- Điểm yếu chí mạng: Bài toán phân phối khóa (Key Distribution Problem). Làm sao hai người chưa từng gặp mặt có thể chia sẻ khóa bí mật với nhau qua mạng Internet công cộng mà không bị kẻ thứ ba nghe lén? Trong mạng P2P với hàng triệu người dùng, mỗi cặp người dùng cần một khóa riêng \(\to\) hệ thống cần duy trì \(O(n^2)\) khóa, điều này hoàn toàn bất khả thi.
Mật mã học bất đối xứng (Asymmetric Cryptography)
Năm 1976, Whitfield Diffie và Martin Hellman đã tạo ra bước đột phá với mô hình khóa công khai: Mỗi người dùng sở hữu một cặp khóa có quan hệ toán học chặt chẽ:
- Khóa bí mật (Private Key): Một chuỗi số ngẫu nhiên chỉ duy nhất chủ tài khoản được biết và bảo vệ an toàn. Private Key được dùng để tạo chữ ký số phê duyệt giao dịch.
- Khóa công khai (Public Key): Được suy ra từ Private Key bằng một hàm toán học một chiều (Trapdoor One-way Function). Public Key được công khai cho toàn thể thế giới để mọi người xác minh chữ ký hoặc gửi tiền đến bạn.
Đặc tính toán học cốt lõi: Bạn có thể dễ dàng tính Public Key từ Private Key, nhưng về mặt tính toán là bất khả thi để đảo ngược từ Public Key ra Private Key.
2. Đường cong Elliptic (Elliptic Curve Cryptography - ECC)
Trước khi ECC trở nên phổ biến, thuật toán RSA (dựa trên bài toán phân tích số nguyên tố lớn) thống trị mật mã học. Tuy nhiên, để đạt mức bảo mật an toàn cho thế kỷ 21, RSA đòi hỏi kích thước khóa lên tới 3072 bits hoặc 4096 bits. Khóa quá lớn gây lãng phí băng thông và tốn tài nguyên tính toán khi truyền tải hàng triệu giao dịch trên blockchain.
Satoshi Nakamoto và các kiến trúc sư blockchain đã quyết định sử dụng Mật mã học đường cong Elliptic (ECC). Một khóa ECC 256 bits mang lại cấp độ bảo mật tương đương khóa RSA 3072 bits, nhưng có kích thước nhỏ hơn gần 12 lần và tốc độ tính toán nhanh hơn vượt trội.
Phương trình đường cong secp256k1
Cả Bitcoin và Ethereum đều sử dụng chung một chuẩn đường cong Elliptic có tên gọi là secp256k1 (do tổ chức SECG thiết lập). Đường cong này được định nghĩa bởi phương trình Weierstrass rút gọn:
\[y^2 = x^3 + 7 \pmod p\]
Được xác định trên trường hữu hạn \(\mathbb{F}_p\), trong đó \(p\) là một số nguyên tố cực lớn:
\[p = 2^{256} - 2^{32} - 977 = \text{FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F}_{16}\]
Do được thực hiện trên trường hữu hạn \(\mathbb{F}_p\), đường cong không phải là một đường liền nét mịn màng mà là một tập hợp phân tán rời rạc gồm các điểm \((x, y)\) với \(x, y \in \{0, 1, \dots, p-1\}\).
Phép cộng điểm hình học (Point Addition & Doubling)
Trên đường cong Elliptic, các nhà toán học định nghĩa một phép toán nhóm Abel (Abelian Group):
- Cộng hai điểm phân biệt \(P + Q\): Vẽ đường thẳng đi qua hai điểm \(P\) và \(Q\). Đường thẳng này sẽ cắt đường cong tại điểm thứ ba \(-R\). Lấy đối xứng điểm \(-R\) qua trục hoành, ta được điểm tổng \(R = P + Q\).
- Nhân đôi điểm \(P + P = 2P\): Vẽ đường tiếp tuyến với đường cong tại điểm \(P\). Tiếp tuyến cắt đường cong tại điểm thứ hai. Lấy đối xứng qua trục hoành, ta được \(2P\).
- Phần tử trung hòa \(\mathcal{O}\): Điểm tại vô cực (Point at Infinity), đóng vai trò như số 0 trong phép cộng thông thường: \(P + \mathcal{O} = P\).
Phép nhân vô hướng (Scalar Multiplication)
Cho một số nguyên \(d\) và một điểm chuẩn \(G\) (Generator Point - Điểm gốc cố định có sẵn trong chuẩn secp256k1):
\[Q = d \cdot G = \underbrace{G + G + \dots + G}_{d \text{ lần}}\]
Bằng thuật toán Nhân đôi và Cộng (Double-and-Add), máy tính có thể tính điểm \(Q\) chỉ trong vài micro-giây với độ phức tạp \(O(\log d)\) phép toán.
Bài toán Logarit rời rạc (ECDLP - Elliptic Curve Discrete Logarithm Problem)
Cho trước điểm gốc \(G\) và điểm công khai \(Q\), tìm lại số nguyên \(d\) sao cho \(Q = d \cdot G\).
Hiện nay, không tồn tại bất kỳ thuật toán cổ điển nào có thể giải bài toán này trong thời gian đa thức. Thuật toán tốt nhất được biết đến (như Pollard's rho) đòi hỏi thời gian \(O(\sqrt{n}) \approx 2^{128}\) phép toán. Đây chính là bức tường bảo vệ toán học vững chắc giúp Private Key của bạn luôn an toàn trước mọi siêu máy tính.
3. Từ Private Key đến Địa chỉ ví Blockchain
Quy trình hình thành một địa chỉ nhận tiền trên blockchain diễn ra hoàn toàn qua các bước toán học xác định một chiều:
Private Key (256 bits)
│
▼ (secp256k1: Q = d * G)
Public Key (Điểm Q: tọa độ (x, y) 64 bytes)
│
▼ (Hàm băm một chiều)
Địa chỉ ví Blockchain (Wallet Address)
Địa chỉ Ethereum
- Lấy tọa độ \((x, y)\) của Public Key (ghép thành 64 bytes nhị phân, bỏ byte tiền tố định dạng).
- Tính mã băm bằng hàm Keccak-256 (hàm băm tiền thân của SHA-3): \[\text{Hash} = \text{Keccak-256}(\text{PublicKey}_{64\text{B}})\]
- Lấy đúng 20 bytes cuối cùng (160 bits) của mã băm và thêm tiền tố
0x. - Chuẩn EIP-55 mã hóa chữ hoa/chữ thường (Checksum) dựa trên mã băm của địa chỉ để chống người dùng gõ nhầm ký tự.
Địa chỉ Bitcoin
- Lấy Public Key (được nén thành 33 bytes: byte chỉ định tính chẵn lẻ của \(y\) kèm 32 bytes của tọa độ \(x\)).
- Thực hiện hàm băm kép: \(\text{Hash160} = \text{RIPEMD-160}(\text{SHA-256}(\text{CompressedPubKey}))\).
- Thêm byte tiền tố phiên bản mạng (ví dụ
0x00cho Bitcoin Mainnet P2PKH). - Tính 4 bytes mã kiểm tra (Checksum) bằng SHA-256 kép và ghép vào cuối.
- Mã hóa toàn bộ chuỗi bằng định dạng Base58Check (loại bỏ các ký tự dễ gây nhầm lẫn như số 0, chữ O lớn, chữ I lớn, chữ l nhỏ).
4. Thuật toán Chữ ký số ECDSA
Khi bạn thực hiện một giao dịch (ví dụ: chuyển 1.5 ETH từ ví của bạn sang ví Bob), phần mềm ví sẽ đóng gói thông tin giao dịch, băm thông điệp thành \(z = \text{Hash}(m)\) và gọi thuật toán ký số ECDSA.
Quy trình Ký thông điệp (Signature Generation)
Đầu vào: Thông điệp đã băm \(z\), Private Key \(d\).
- Chọn một số nguyên ngẫu nhiên bí mật \(k \in [1, n-1]\) (gọi là Ephemeral Key hoặc Nonce), trong đó \(n\) là bậc (order) của nhóm điểm đường cong secp256k1.
- Tính điểm trên đường cong: \(R = (x_R, y_R) = k \cdot G\).
- Lấy thành phần \(r\): \[r = x_R \pmod n\] Nếu \(r = 0\), quay lại bước 1 chọn \(k\) khác.
- Tính thành phần \(s\): \[s = k^{-1} \cdot (z + r \cdot d) \pmod n\] Trong đó \(k^{-1}\) là nghịch đảo modular của \(k\) theo modulo \(n\) (tính bằng giải thuật Euclid mở rộng). Nếu \(s = 0\), quay lại bước 1.
- Cặp giá trị \((r, s)\) chính là Chữ ký số ECDSA của giao dịch.
Quy trình Xác thực Chữ ký (Signature Verification)
Bất kỳ ai (các thợ đào, nút mạng xác thực) có trong tay: Thông điệp băm \(z\), Chữ ký \((r, s)\), và Public Key \(Q\) của người gửi đều có thể kiểm tra:
- Kiểm tra miền giá trị: \(r, s \in [1, n-1]\). Nếu không thỏa mãn, lập tức bác bỏ.
- Tính giá trị nghịch đảo: \(w = s^{-1} \pmod n\).
- Tính hai hệ số trợ lực: \[u_1 = z \cdot w \pmod n\] \[u_2 = r \cdot w \pmod n\]
- Tính điểm đường cong kiểm tra: \[R' = (x_R', y_R') = u_1 \cdot G + u_2 \cdot Q\]
- Nếu \(R' = \mathcal{O}\) (điểm vô cực), chữ ký không hợp lệ.
- So sánh: Nếu \(x_R' \pmod n == r\), chữ ký được chứng minh hợp lệ tuyệt đối!
Chứng minh toán học tính đúng đắn
Tại sao phép kiểm tra này lại luôn luôn chính xác? Hãy nhìn vào phép biến đổi:
\[R' = u_1 \cdot G + u_2 \cdot Q = (z \cdot w) \cdot G + (r \cdot w) \cdot (d \cdot G)\] \[R' = w \cdot (z + r \cdot d) \cdot G\] Vì \(w = s^{-1} \pmod n\) và theo định nghĩa lúc ký thì \(s = k^{-1} \cdot (z + r \cdot d) \pmod n\), suy ra: \[w \cdot (z + r \cdot d) = s^{-1} \cdot s \cdot k = k \pmod n\] Do đó: \[R' = k \cdot G = R\] Như vậy hoành độ của \(R'\) hiển nhiên bằng hoành độ của \(R\), tức là \(x_R' \pmod n = r\). Phép chứng minh hoàn tất!
5. Lỗ hổng chết người: Tái sử dụng Nonce (Nonce Reuse Attack)
Trong thuật toán ECDSA, giá trị \(k\) được gọi là "Ephemeral Nonce" — tức là một số ngẫu nhiên chỉ được dùng duy nhất một lần. Nếu một lập trình viên thiếu kinh nghiệm tạo ra bộ sinh số ngẫu nhiên lỗi khiến cùng một giá trị \(k\) bị dùng lại cho hai giao dịch khác nhau, thảm họa bảo mật sẽ lập tức xảy ra.
Cách thức kẻ tấn công bẻ khóa Private Key
Giả sử người dùng ký hai thông điệp khác nhau \(z_1\) và \(z_2\) với cùng một nonce \(k\): Chữ ký thứ nhất: \(s_1 = k^{-1}(z_1 + r \cdot d) \pmod n\) Chữ ký thứ hai: \(s_2 = k^{-1}(z_2 + r \cdot d) \pmod n\) (Lưu ý: Vì dùng chung \(k\), giá trị \(R = k \cdot G\) giống nhau nên thành phần \(r\) của hai chữ ký hoàn toàn trùng khớp!).
Kẻ tấn công lấy hai phương trình trừ cho nhau: \[s_1 - s_2 = k^{-1}(z_1 - z_2) \pmod n\] Từ đây suy ra trực tiếp giá trị nonce \(k\): \[k = \frac{z_1 - z_2}{s_1 - s_2} \pmod n\] Một khi đã tính được \(k\), kẻ tấn công thay \(k\) ngược lại vào phương trình thứ nhất để rút ra Private Key \(d\): \[d = \frac{s_1 \cdot k - z_1}{r} \pmod n\] Toàn bộ quá trình giải toán này chỉ mất chưa đầy 1 phần nghìn giây!
Sự cố lịch sử
- Sony PlayStation 3 (2010): Nhóm hacker fail0verflow đã phát hiện Sony sử dụng một hằng số \(k\) cố định trong mã nguồn kiểm tra chữ ký hệ điều hành PS3. Toàn bộ Private Key của hãng bị giải mã công khai, phá vỡ hoàn toàn bức tường bảo mật bản quyền game.
- Android Bitcoin Wallet (2013): Thư viện
java.security.SecureRandomtrên hệ điều hành Android bị lỗi khởi tạo seed trùng lặp, khiến nhiều ví Bitcoin tạo ra cùng một giá trị \(k\). Hàng loạt người dùng đã bị hacker quét sạch ví trong tích tắc.
Giải pháp chuẩn mực: RFC 6979
Để loại trừ vĩnh viễn rủi ro này, tiêu chuẩn RFC 6979 ra đời: Giá trị \(k\) không còn được lấy từ bộ sinh số ngẫu nhiên phần cứng nữa, mà được tính toán một cách tất định (Deterministic Nonce) bằng hàm băm mật mã học từ chính Private Key và nội dung thông điệp:
\(k\) được sinh bởi quy trình HMAC-DRBG (mục 3.2 của RFC 6979): lặp các phép HMAC-SHA256 với đầu vào là khóa bí mật \(d\) và mã băm \(z\) cho tới khi được \(k \in [1, n-1]\).
Cách làm này đảm bảo \(k\) luôn luôn duy nhất cho mỗi thông điệp khác nhau, đồng thời hoàn toàn không phụ thuộc vào chất lượng của bộ sinh số ngẫu nhiên hệ thống.
Chủ đề này nằm trong Lecture 01 - Tổng quan về Blockchain của Khóa Blockchain. Xem đề cương
6. Bài toán lập trình thực chiến: Mô phỏng hệ thống Ký và Xác thực Chữ ký số
Để nắm vững bản chất đại số của chữ ký số mà không bị phụ thuộc vào các thư viện đóng gói sẵn, chúng ta sẽ tự tay lập trình ECDSA đúng theo các bước ở mục 4 trên một đường cong thu nhỏ có cùng phương trình với secp256k1:
- Đường cong: \(y^2 = x^3 + 7\) trên trường \(\mathbb{F}_p\) với \(p = 1051\) (secp256k1 dùng \(p \approx 2^{256}\)).
- Đường cong có đúng \(1093\) điểm (kể cả điểm vô cực \(\mathcal{O}\)), và \(1093\) là số nguyên tố nên mọi điểm khác \(\mathcal{O}\) đều sinh ra cả nhóm.
- Điểm sinh: \(G = (3, 385)\), vì \(385^2 \equiv 3^3 + 7 \pmod{1051}\); bậc của \(G\) là \(n = 1093\).
- Hàm băm thông điệp: SHA-256, giữ 11 bit đầu (bằng số bit của \(n\)) làm \(z\), đúng cách ECDSA cắt mã băm khi \(n\) ngắn hơn 256 bit.
Bốn hàm chính: generate_keypair(d) tính \(Q = d \cdot G\) bằng Nhân đôi và Cộng, sign_message(d, k, m) ký với nonce \(k\) cho trước, verify_signature(Q, m, r, s) xác thực, và recover_private_key(...) thực hiện đúng tấn công tái sử dụng nonce ở mục 5. Ví dụ: khóa bí mật \(d = 777\) cho khóa công khai \(Q = (606, 389)\); ký thông điệp tx:alice->bob:50 với \(k = 300\) được \((r, s) = (965, 621)\). Nếu dùng lại \(k = 300\) để ký tx:alice->bob:5000, chữ ký mới \((965, 187)\) có cùng \(r\), và từ hai chữ ký này recover_private_key tìm lại đúng \(k = 300\) và \(d = 777\).
Đường cong này chỉ để học: với \(n = 1093\), ai cũng thử hết các khóa trong tích tắc. Phần mềm thật dùng secp256k1 qua một thư viện mật mã đã được kiểm định, và sinh \(k\) theo RFC 6979.
Khi tự viết lại code này, bạn có thể tự kiểm theo ba bước: thay tham số đường cong bằng tham số P-256 trong SEC 2 rồi so với ví dụ mẫu ở phụ lục A.2.5 của RFC 6979 (cùng khóa bí mật, cùng \(k\) thì phải ra đúng \(r\), \(s\) đã công bố); với đường cong nhỏ, dựng bảng mọi bội \(i \cdot G\) bằng cách cộng dần rồi so với kết quả Nhân đôi và Cộng; và sửa thông điệp, sửa \(r\) hay \(s\) thì phần xác thực phải trả về không hợp lệ.
Cài đặt giải thuật thực chiến
#include <cstdint>
#include <string>
#include <utility>
// ECDSA thu nhỏ trên đường cong y^2 = x^3 + 7 (cùng phương trình với secp256k1) theo đúng các bước ở mục 4 và 5.
// Số nhỏ để chạy tay được, CHỈ ĐỂ HỌC: bậc nhóm N = 1093 nên ai cũng thử hết 1092 khóa trong tích tắc.
const long long P = 1051; // số nguyên tố của trường F_P
const long long A = 0, B = 7; // y^2 = x^3 + A*x + B
const long long N = 1093; // bậc của điểm sinh G, là số nguyên tố
struct Point {
long long x, y;
bool inf; // true: điểm vô cực O
};
const Point O = {0, 0, true};
const Point G = {3, 385, false}; // 385^2 ≡ 3^3 + 7 (mod 1051)
long long mod(long long a, long long m) { return ((a % m) + m) % m; }
// Nghịch đảo modulo m bằng giải thuật Euclid mở rộng (giả sử gcd(a, m) = 1)
long long mod_inverse(long long a, long long m) {
long long old_r = mod(a, m), r = m, old_s = 1, s = 0;
while (r != 0) {
long long q = old_r / r, t = old_r - q * r;
old_r = r; r = t;
t = old_s - q * s; old_s = s; s = t;
}
return mod(old_s, m);
}
bool is_on_curve(const Point& p) {
if (p.inf) return true;
return p.x >= 0 && p.x < P && p.y >= 0 && p.y < P && mod(p.y * p.y - p.x * p.x % P * p.x - A * p.x - B, P) == 0;
}
// Cộng hai điểm (mục 2): cát tuyến khi hai điểm khác nhau, tiếp tuyến khi nhân đôi
Point point_add(const Point& p1, const Point& p2) {
if (p1.inf) return p2;
if (p2.inf) return p1;
if (p1.x == p2.x && mod(p1.y + p2.y, P) == 0) return O; // P + (-P) = O
long long lam;
if (p1.x == p2.x && p1.y == p2.y) lam = mod((3 * p1.x * p1.x + A) % P * mod_inverse(2 * p1.y, P), P);
else lam = mod(mod(p2.y - p1.y, P) * mod_inverse(p2.x - p1.x, P), P);
long long x3 = mod(lam * lam - p1.x - p2.x, P);
return {x3, mod(lam * (p1.x - x3) - p1.y, P), false};
}
// k * p bằng Nhân đôi và Cộng (Double-and-Add): O(log k) phép cộng điểm
Point scalar_mult(long long k, Point p) {
Point result = O;
while (k > 0) {
if (k & 1) result = point_add(result, p);
p = point_add(p, p);
k >>= 1;
}
return result;
}
// SHA-256 theo chuẩn FIPS 180-4, cài tay để chỉ cần thư viện chuẩn C++
std::string sha256(const std::string& msg) {
static const uint32_t K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
uint32_t h[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
std::string m = msg;
uint64_t bit_len = static_cast<uint64_t>(msg.size()) * 8;
m += static_cast<char>(0x80);
while (m.size() % 64 != 56) m += static_cast<char>(0);
for (int i = 7; i >= 0; --i) m += static_cast<char>((bit_len >> (8 * i)) & 0xff);
auto rotr = [](uint32_t x, int n) { return (x >> n) | (x << (32 - n)); };
for (size_t off = 0; off < m.size(); off += 64) {
uint32_t w[64];
for (int t = 0; t < 16; ++t) {
w[t] = 0;
for (int j = 0; j < 4; ++j) w[t] = (w[t] << 8) | static_cast<unsigned char>(m[off + 4 * t + j]);
}
for (int t = 16; t < 64; ++t) {
uint32_t s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ (w[t - 15] >> 3);
uint32_t s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ (w[t - 2] >> 10);
w[t] = s1 + w[t - 7] + s0 + w[t - 16];
}
uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
for (int t = 0; t < 64; ++t) {
uint32_t t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K[t] + w[t];
uint32_t t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c));
hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2;
}
h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e; h[5] += f; h[6] += g; h[7] += hh;
}
std::string out;
for (uint32_t v : h)
for (int i = 3; i >= 0; --i) out += static_cast<char>((v >> (8 * i)) & 0xff);
return out;
}
// z = Hash(m): SHA-256 rồi giữ số bit đầu bằng số bit của N (N = 1093 có 11 bit), đúng cách ECDSA cắt mã băm
long long hash_to_int(const std::string& message) {
std::string h = sha256(message);
uint64_t top = 0;
for (int i = 0; i < 8; ++i) top = (top << 8) | static_cast<unsigned char>(h[i]);
int n_bits = 0;
for (long long t = N; t > 0; t >>= 1) ++n_bits;
return static_cast<long long>(top >> (64 - n_bits));
}
// Khóa công khai Q = d * G, với khóa bí mật d trong [1, N - 1]
Point generate_keypair(long long priv_key) {
if (priv_key < 1 || priv_key >= N) return O; // khóa không hợp lệ
return scalar_mult(priv_key, G);
}
// Ký theo mục 4: R = k*G, r = x_R mod N, s = k^-1 (z + r*d) mod N.
// Trả về {0, 0} khi k không hợp lệ hoặc r = 0 hoặc s = 0: khi đó phải chọn k khác.
std::pair<long long, long long> sign_message(long long priv_key, long long nonce_k, const std::string& message) {
if (nonce_k < 1 || nonce_k >= N) return {0, 0};
long long z = hash_to_int(message);
long long r = mod(scalar_mult(nonce_k, G).x, N);
if (r == 0) return {0, 0};
long long s = mod(mod_inverse(nonce_k, N) * mod(z + r * priv_key, N), N);
if (s == 0) return {0, 0};
return {r, s};
}
// Xác thực theo mục 4, chỉ cần khóa công khai Q
std::pair<bool, std::string> verify_signature(const Point& pub_key, const std::string& message, long long r, long long s) {
if (r < 1 || r >= N || s < 1 || s >= N) return {false, "ERR_OUT_OF_RANGE"};
if (pub_key.inf || !is_on_curve(pub_key)) return {false, "ERR_INVALID_PUBKEY"};
long long z = hash_to_int(message);
long long w = mod_inverse(s, N);
long long u1 = mod(z % N * w, N), u2 = mod(r * w, N);
Point R = point_add(scalar_mult(u1, G), scalar_mult(u2, pub_key));
if (!R.inf && R.x % N == r) return {true, "VALID_SIGNATURE"};
return {false, "ERR_INVALID_SIGNATURE"};
}
// Tấn công tái sử dụng nonce (mục 5): hai chữ ký có cùng r thì tìm lại được (k, d).
// Trả về {0, 0} khi không áp dụng được (r khác nhau hoặc s1 = s2).
std::pair<long long, long long> recover_private_key(const std::string& msg1, std::pair<long long, long long> sig1,
const std::string& msg2, std::pair<long long, long long> sig2) {
long long r = sig1.first, s1 = sig1.second, s2 = sig2.second;
if (r != sig2.first || mod(s1 - s2, N) == 0) return {0, 0};
long long z1 = hash_to_int(msg1), z2 = hash_to_int(msg2);
long long k = mod(mod(z1 - z2, N) * mod_inverse(s1 - s2, N), N);
long long d = mod(mod(s1 * k - z1, N) * mod_inverse(r, N), N);
return {k, d};
}
# -*- coding: utf-8 -*-
"""ECDSA thu nhỏ trên đường cong y^2 = x^3 + 7 (cùng phương trình với secp256k1) theo đúng các bước ở mục 4 và 5.
Số nhỏ để chạy tay được, CHỈ ĐỂ HỌC: bậc nhóm N = 1093 nên ai cũng thử hết 1092 khóa trong tích tắc. Dùng thật thì phải
dùng secp256k1 (p và n cỡ 2^256) và một thư viện mật mã đã được kiểm định.
"""
import hashlib
from typing import Optional, Tuple
# Tham số miền: đường cong y^2 = x^3 + A*x + B trên trường hữu hạn F_P
P = 1051 # số nguyên tố của trường
A, B = 0, 7 # y^2 = x^3 + 7 như secp256k1
G = (3, 385) # điểm sinh: 385^2 ≡ 3^3 + 7 (mod 1051)
N = 1093 # bậc của G, là số nguyên tố (đường cong có đúng 1093 điểm, kể cả điểm vô cực)
Point = Optional[Tuple[int, int]] # None là điểm vô cực O
def mod_inverse(a: int, m: int) -> int:
"""Nghịch đảo của a theo modulo m bằng giải thuật Euclid mở rộng."""
old_r, r = a % m, m
old_s, s = 1, 0
while r:
q = old_r // r
old_r, r = r, old_r - q * r
old_s, s = s, old_s - q * s
if old_r != 1:
raise ValueError("không có nghịch đảo")
return old_s % m
def is_on_curve(pt: Point) -> bool:
if pt is None:
return True
x, y = pt
return 0 <= x < P and 0 <= y < P and (y * y - x * x * x - A * x - B) % P == 0
def point_add(p1: Point, p2: Point) -> Point:
"""Cộng hai điểm (mục 2): cát tuyến khi hai điểm khác nhau, tiếp tuyến khi nhân đôi."""
if p1 is None:
return p2
if p2 is None:
return p1
x1, y1 = p1
x2, y2 = p2
if x1 == x2 and (y1 + y2) % P == 0:
return None # P + (-P) = O
if p1 == p2:
lam = (3 * x1 * x1 + A) * mod_inverse(2 * y1, P) % P
else:
lam = (y2 - y1) * mod_inverse(x2 - x1, P) % P
x3 = (lam * lam - x1 - x2) % P
return (x3, (lam * (x1 - x3) - y1) % P)
def scalar_mult(k: int, pt: Point) -> Point:
"""k * pt bằng Nhân đôi và Cộng (Double-and-Add): O(log k) phép cộng điểm."""
result = None
while k > 0:
if k & 1:
result = point_add(result, pt)
pt = point_add(pt, pt)
k >>= 1
return result
def hash_to_int(message: str) -> int:
"""z = Hash(m): SHA-256 rồi giữ số bit đầu bằng số bit của N, đúng cách ECDSA cắt mã băm."""
h = int.from_bytes(hashlib.sha256(message.encode("utf-8")).digest(), "big")
return h >> max(0, 256 - N.bit_length())
def generate_keypair(priv_key: int) -> Point:
"""Khóa công khai Q = d * G, với khóa bí mật d trong [1, N - 1]."""
if not 1 <= priv_key < N:
raise ValueError("khóa bí mật phải nằm trong [1, N - 1]")
return scalar_mult(priv_key, G)
def sign_message(priv_key: int, nonce_k: int, message: str) -> Optional[Tuple[int, int]]:
"""Ký theo mục 4: R = k*G, r = x_R mod N, s = k^-1 (z + r*d) mod N.
Trả về None khi k không hợp lệ hoặc r = 0 hoặc s = 0: khi đó phải chọn k khác."""
if not 1 <= nonce_k < N:
return None
z = hash_to_int(message)
r = scalar_mult(nonce_k, G)[0] % N
if r == 0:
return None
s = mod_inverse(nonce_k, N) * (z + r * priv_key) % N
if s == 0:
return None
return (r, s)
def verify_signature(pub_key: Point, message: str, r: int, s: int) -> Tuple[bool, str]:
"""Xác thực theo mục 4, chỉ cần khóa công khai Q."""
if not (1 <= r < N and 1 <= s < N):
return (False, "ERR_OUT_OF_RANGE")
if pub_key is None or not is_on_curve(pub_key):
return (False, "ERR_INVALID_PUBKEY")
z = hash_to_int(message)
w = mod_inverse(s, N)
u1, u2 = z * w % N, r * w % N
R = point_add(scalar_mult(u1, G), scalar_mult(u2, pub_key))
if R is not None and R[0] % N == r:
return (True, "VALID_SIGNATURE")
return (False, "ERR_INVALID_SIGNATURE")
def recover_private_key(msg1: str, sig1: Tuple[int, int], msg2: str, sig2: Tuple[int, int]) -> Optional[Tuple[int, int]]:
"""Tấn công tái sử dụng nonce (mục 5): hai chữ ký có cùng r thì tìm lại được (k, d).
k = (z1 - z2) / (s1 - s2) mod N, d = (s1*k - z1) / r mod N."""
(r1, s1), (r2, s2) = sig1, sig2
if r1 != r2 or (s1 - s2) % N == 0:
return None
z1, z2 = hash_to_int(msg1), hash_to_int(msg2)
k = (z1 - z2) * mod_inverse(s1 - s2, N) % N
d = (s1 * k - z1) * mod_inverse(r1, N) % N
return (k, d)
Phân tích độ phức tạp thuật toán
- Tạo cặp khóa (
generate_keypair): Nhân đôi và Cộng duyệt từng bit của \(d\), tốn \(O(\log n)\) phép cộng điểm; mỗi phép cộng điểm cần một phép nghịch đảo modulo \(p\) bằng Euclid mở rộng. Với secp256k1, \(d\) có 256 bit nên cần khoảng 256 phép nhân đôi và trung bình 128 phép cộng. - Ký thông điệp (
sign_message): 1 phép nhân vô hướng \(k \cdot G\), 1 phép băm thông điệp độ dài \(M\) tốn \(O(M)\), và 1 phép nghịch đảo \(k^{-1} \bmod n\). Tổng độ phức tạp là \(O(M + \log n)\) phép toán. - Xác thực chữ ký (
verify_signature): 1 phép băm, 1 phép nghịch đảo \(s^{-1} \bmod n\) và 2 phép nhân vô hướng \(u_1 \cdot G\), \(u_2 \cdot Q\). Tổng thời gian là \(O(M + \log n)\). - Tấn công tái sử dụng nonce (
recover_private_key): chỉ 2 phép băm và 2 phép nghịch đảo modulo \(n\), gần như tức thì. - Không gian bộ nhớ: \(O(1)\) ngoài thông điệp đầu vào.
7. Sự chuyển dịch thế hệ: Từ ECDSA sang Chữ ký Schnorr
Mặc dù ECDSA đã phục vụ xuất sắc cho Bitcoin và Ethereum trong hơn một thập kỷ, nó vẫn có một nhược điểm toán học: thiếu tính tuyến tính (Non-linear).
Năm 2021, bản nâng cấp Taproot (BIP 340) của Bitcoin đã chính thức tích hợp chuẩn Chữ ký Schnorr trên cùng đường cong secp256k1:
- Gom chữ ký (Signature Aggregation / MuSig): Trong ví đa chữ ký n-of-n (ví dụ \(3\)-of-\(3\)), ECDSA phải lưu cả 3 chữ ký riêng lẻ lên khối. Với Schnorr và giao thức MuSig2 (BIP 327), các bên phối hợp tạo một chữ ký tổng hợp duy nhất, trong đó phần \(s\) là tổng các chữ ký thành phần: \[s_{\text{total}} = s_1 + s_2 + s_3\] Điều này giúp tiết kiệm đáng kể kích thước khối và giảm phí giao dịch.
- Quyền riêng tư tuyệt đối (Privacy): Một giao dịch đa chữ ký phức tạp nhìn từ bên ngoài hoàn toàn giống hệt một giao dịch chuyển tiền đơn lẻ thông thường, ngăn chặn bên ngoài theo dõi cấu trúc ví nội bộ của người dùng.
8. Cơ chế phục hồi khóa công khai (Public Key Recovery) trong Ethereum
Một điểm cải tiến độc đáo trong thiết kế của Ethereum so với Bitcoin là việc tích hợp cơ chế Phục hồi khóa công khai (Public Key Recovery), thể hiện qua hàm tiền biên dịch ecrecover nổi tiếng của máy ảo EVM.
Vấn đề tối ưu hóa kích thước giao dịch
Trong giao thức Bitcoin nguyên bản, mỗi giao dịch bắt buộc phải đính kèm cả Public Key đầy đủ của người gửi (33 hoặc 65 bytes) cùng với chữ ký số (r, s). Trong một mạng lưới xử lý hàng triệu giao dịch mỗi ngày, việc truyền tải và lưu trữ Public Key lặp đi lặp lại gây lãng phí băng thông khổng lồ.
Giải pháp với tham số phục hồi v (Recovery Identifier)
Trên đường cong Elliptic, với mỗi giá trị hoành độ x = r, phương trình đường cong y^2 = x^3 + 7 mod p có thể sinh ra tối đa 2 giá trị tung độ y đối xứng nhau qua trục hoành, cùng với khả năng hoành độ vượt qua bậc nhóm con n.
Để giải quyết sự mơ hồ này, Ethereum bổ sung thêm một giá trị byte duy nhất v (gọi là Recovery ID):
- Trong chuẩn nguyên bản, v thuộc tập {27, 28}.
- Kể từ đề xuất cải tiến EIP-155 (chống tấn công phát lại giữa các chuỗi - Replay Attack Protection), v được tính toán kết hợp với mã định danh chuỗi (Chain ID): v = ChainID * 2 + 35 hoặc ChainID * 2 + 36
- Với giao dịch kiểu mới (EIP-2718, EIP-1559), Chain ID là một trường riêng của giao dịch, và chữ ký chỉ còn bit chẵn lẻ
signature_y_parity(0 hoặc 1) thay cho v.
Nhờ có bộ ba chữ ký (v, r, s), bất kỳ nút mạng Ethereum nào cũng có thể tự động khôi phục chính xác 100% tọa độ điểm Public Key Q của người gửi mà người dùng không cần phải đính kèm Public Key vào gói tin giao dịch. Từ Public Key khôi phục được, máy ảo EVM băm Keccak-256 để kiểm tra xem địa chỉ ví đó có khớp với tài khoản người gửi msg.sender hay không.
9. Kiến trúc Ví phân cấp đơn định (HD Wallet) và Trừu tượng hóa tài khoản
Trong thực tế phát triển phần mềm Web3, lập trình viên không bao giờ quản lý các cặp khóa rời rạc mà luôn sử dụng các chuẩn kiến trúc ví hiện đại:
Chuẩn ví phân cấp đơn định (Hierarchical Deterministic Wallet - BIP 32 / BIP 44)
Người dùng chỉ cần ghi nhớ một chuỗi cụm từ hạt giống (Mnemonic Seed Phrase) gồm 12 hoặc 24 từ tiếng Anh theo chuẩn BIP 39. Từ hạt giống gốc này, thông qua hàm sinh khóa HMAC-SHA512, hệ thống có thể tạo ra một cây phân cấp chứa hàng triệu cặp Private Key và Public Key hoàn toàn xác định theo đường dẫn dẫn xuất (Derivation Path):
m / 44' / 60' / 0' / 0 / k
Trong đó 44' là chuẩn BIP 44, 60' là mã định danh của Ethereum (0' cho Bitcoin), 0' là số tài khoản, và k là chỉ số địa chỉ ví con thứ k. Kiến trúc này cho phép các doanh nghiệp và sàn giao dịch sinh ra các địa chỉ nạp tiền mới liên tục mà không cần tạo seed mới, đồng thời hỗ trợ khóa công khai mở rộng (xpub) để theo dõi số dư ví mà không có nguy cơ làm lộ Private Key.
Trừu tượng hóa tài khoản (Account Abstraction - ERC-4337)
Mặc dù ECDSA rất an toàn, nhưng nó gắn liền với tài khoản sở hữu bên ngoài (Externally Owned Account - EOA) vốn tồn tại nhiều rủi ro: mất khóa bí mật đồng nghĩa với mất toàn bộ tài sản vĩnh viễn.
Chuẩn ERC-4337 mở ra kỷ nguyên mới khi biến ví người dùng thành một Hợp đồng thông minh (Smart Contract Wallet). Thay vì phụ thuộc cứng nhắc vào một cặp khóa ECDSA đơn lẻ, ví hợp đồng thông minh cho phép:
- Phục hồi tài khoản thông qua người giám hộ (Social Recovery): Bạn bè hoặc người thân có thể giúp bạn khôi phục quyền truy cập nếu bạn đánh mất thiết bị.
- Xác thực đa yếu tố (Multi-factor Authentication): Tích hợp cảm biến vân tay FaceID/TouchID thông qua chuẩn mã hóa WebAuthn (secp256r1) ngay trên trình duyệt web.
- Thanh toán phí Gas bằng token linh hoạt (Paymaster): Cho phép trả phí mạng bằng token ERC-20 bất kỳ (USDT, USDC) hoặc được ứng dụng tài trợ phí Gas hoàn toàn miễn phí.
10. Tổng kết
Chữ ký số và mật mã học khóa công khai là phát minh đã biến giấc mơ về một nền tài chính phi tập trung thành hiện thực:
- Cho phép người dùng toàn quyền kiểm soát tài sản kỹ thuật số ("Not your keys, not your coins").
- Ngăn chặn triệt để hành vi giả mạo và chi tiêu hai lần thông qua các định luật toán học bất biến.
- Đòi hỏi quy trình quản trị khóa khắt khe và lập trình viên phải thấu hiểu các cạm bẫy bảo mật (như tái sử dụng Nonce).
Để thực hành tạo ví, quản lý private key và lập trình smart contract trên Solana bằng Rust và Anchor, hãy tham khảo Khóa học Lập trình Blockchain tại Big-O Coding.
Nhập môn Blockchain và Solana: hiểu Web3, lập trình Smart Contract, tự xây dApps bằng Rust/TypeScript. 16 buổi online, học thử buổi 1 miễn phí.


