Skip to content
TungDaDev's Blog

Chữ ký số trong Java: từ Signature thô tới CMS với BouncyCastle

Brown paper with silver round pendant
Published on
10 mins read

Một lệnh chuyển tiền đi từ hệ thống của bạn sang đối tác. Bên kia nhận được, nhìn số tài khoản, số tiền. Trước khi xử lý, họ cần biết chắc hai điều: lệnh này đúng là do bạn gửi, và dọc đường không ai sửa con số nào.

Chữ ký số (digital signature) trả lời được cả hai: tính xác thực và tính toàn vẹn. Nó còn chống chối bỏ (non-repudiation), vì chỉ người giữ khoá bí mật mới tạo ra được chữ ký hợp lệ.

Trong Java có hai cách làm: ký thô bằng java.security.Signature có sẵn trong JDK, hoặc đóng gói chữ ký theo chuẩn CMS (RFC 5652) bằng BouncyCastle để trao đổi giữa các hệ thống. Và có một lỗi rất hay gặp ở bước verify(), kể cả khi code ký đã đúng.

Muốn bắt đầu ký dữ liệu, bạn cần một cặp khoá bất đối xứng: một private-key chỉ người ký được giữ kín, đi kèm một public-key (hoặc tốt hơn là một certificate X.509) công khai cho bên nhận dùng để kiểm tra.

# ký bằng Java thuần

Cách đơn giản nhất để tạo chữ ký trong Java:

Signature ecdsaSignature = Signature.getInstance("SHA256withECDSA");
ecdsaSignature.initSign(eccPrivateKey);
ecdsaSignature.update(dataToSign);
byte[] signature = ecdsaSignature.sign();

Đoạn code này tạo ra một chữ ký thô (raw signature): dữ liệu được băm ra (hash) bằng SHA-256, rồi thuật toán ký dùng giá trị băm đó cùng private-key để tính ra chữ ký.

Hay có câu "ký là mã hoá hash bằng private key". Cách nói này tạm gần đúng với RSA kiểu cũ (PKCS#1 v1.5), còn với ECDSA thì không có bước mã hoá hay giải mã nào cả: chữ ký là một cặp số (r, s) tính từ hash, private key và một số ngẫu nhiên dùng một lần. Với curve P-256, sign() của Java trả về cặp số này đóng gói DER, dài khoảng 70-72 byte.

Muốn kiểm tra dữ liệu có bị sửa hay không, bên nhận băm lại dữ liệu rồi đưa hash, chữ ký và public-key vào phép kiểm tra của thuật toán. Kết quả chỉ là đúng hoặc sai. Bước này gọi là xác minh (verify) chữ ký:

Signature ecdsaSignature = Signature.getInstance("SHA256withECDSA");
ecdsaSignature.initVerify(certificate);
ecdsaSignature.update(dataToVerify);
boolean isValid = ecdsaSignature.verify(rawSignature);

# ưu điểm

Chữ ký đầu ra rất gọn (chỉ vài chục byte với ECDSA), code ngắn và không cần thêm thư viện ngoài JDK, hợp khi bạn chỉ cần ký nhanh gọn giữa các service nội bộ đã hiểu rõ nhau.

# nhược điểm

Đổi lại, mảng byte chữ ký thô chỉ chứa mỗi kết quả toán học chứ không mang theo ngữ cảnh nào cả. Bên kiểm tra (verifier) phải tự biết trước phải dùng certificate nào và thuật toán gì (SHA256withECDSA hay SHA512withRSA), đồng thời hai bên phải tự quy ước cách gửi kèm dữ liệu gốc với chữ ký. Vì vậy kiểu chữ ký này chỉ tiện khi gói gọn trong một hệ thống khép kín.

# cú pháp mã hoá (Cryptographic Message Syntax - CMS)

Khi trao đổi dữ liệu với đối tác bên ngoài hoặc lưu trữ lâu dài, người ta dùng một định dạng chữ ký chuẩn mang theo đủ thông tin tự mô tả. Chuẩn phổ biến nhất là Cryptographic Message Syntax (CMS), định nghĩa trong RFC5652 (tiền thân là PKCS#7).

CMS mô tả nhiều kiểu dữ liệu mật mã, nhưng ở đây mình chỉ quan tâm tới dạng Signed-data. Một gói Signed-data đóng chung chữ ký với thông tin thuật toán và chứng thư số của người ký, giúp bên nhận xác minh dễ hơn hẳn. Vậy tạo cấu trúc này trong Java kiểu gì?

Java cung cấp sẵn bộ khung cho các thao tác mật mã qua Java Cryptography Architecture (JCA) và phần mở rộng Java Cryptography Extension (JCE). Các bản cài đặt thực tế bên dưới được gọi là provider. JDK đi kèm sẵn vài provider, mỗi cái phụ trách một mảng: SUN (hash, DSA, keystore...), SunRsaSign (RSA), SunEC (ECDSA, provider chạy đoạn SHA256withECDSA ở trên), SunJCE (cipher, MAC...).

Có điều JCE không có interface cho Cryptographic Message Syntax, nên bạn phải dùng thêm thư viện khác. BouncyCastle là lựa chọn tốt: nó là một JCE provider, kèm thêm nhiều chức năng mã hoá ở mức trừu tượng cao. Code tạo chữ ký với CMS và BouncyCastle trông như sau (lấy từ JavaDoc của BouncyCastle, cần thêm bcprov và bcpkix vào project):

List certList = new ArrayList();
CMSTypedData  msg = new CMSProcessableByteArray("Hello world!".getBytes());
certList.add(signCert);
Store certs = new JcaCertStore(certList);
CMSSignedDataGenerator gen = new CMSSignedDataGenerator();
ContentSigner sha256Signer = new JcaContentSignerBuilder("SHA256withECDSA").build(signKP.getPrivate());
 
gen.addSignerInfoGenerator(
  new JcaSignerInfoGeneratorBuilder(
    new JcaDigestCalculatorProviderBuilder().build())
      .build(sha256Signer, signCert));
 
gen.addCertificates(certs);
CMSSignedData sigData = gen.generate(msg, false);

Bạn được chọn có nhét dữ liệu gốc vào trong CMS Container cùng với chữ ký hay không, tức là chữ ký dạng attached (đính kèm dữ liệu) hay detached (tách rời). Tham số thứ hai (encapsulate) của generate() quyết định chuyện này: false như ví dụ trên là detached. Với chữ ký detached, bên nhận phải tự ghép lại dữ liệu gốc khi đọc container bằng new CMSSignedData(new CMSProcessableByteArray(data), signatureBytes) rồi mới xác minh được.

Một CMS Container hoàn chỉnh sẽ gói sẵn chữ ký, danh sách certificate dùng để xác minh, định danh thuật toán băm/ký đã dùng, và cả dữ liệu gốc nếu chọn chế độ attached. Hơn nữa, một container có thể chứa nhiều SignerInformation, cho phép nhiều người cùng ký lên một tài liệu và gửi tất cả chữ ký đi chung trong một gói duy nhất.

Còn đây là code xác minh một CMSSignedData (lấy từ JavaDoc của BouncyCastle):

Store certStore = cmsSignedData.getCertificates();
SignerInformationStore signers = cmsSignedData.getSignerInfos();
Collection c = signers.getSigners();
Iterator it = c.iterator();
 
while (it.hasNext()){
  SignerInformation signer = (SignerInformation)it.next();
  Collection certCollection = certStore.getMatches(signer.getSID());
  Iterator certIt = certCollection.iterator();
  X509CertificateHolder cert = (X509CertificateHolder)certIt.next();
  if (signer.verify(new JcaSimpleSignerInfoVerifierBuilder().build(cert))) {
    // successfully verified
  }
}

# light weight

Với các bản JDK cũ, muốn dùng hết chức năng của một bản implement JCE thì bạn phải cài "unlimited strength jurisdiction policy files" cho JVM. Không cài thì có thể gặp lỗi kiểu này:

java.lang.SecurityException: Unsupported keysize or algorithm parameters
or java.security.InvalidKeyException: Illegal key size

Nguyên nhân là các quy định hạn chế xuất khẩu công nghệ mã hoá của Mỹ, giới hạn độ dài khoá (ví dụ AES chỉ tới 128 bit). Ngày trước cài JDK mặc định xong thì các hạn chế này vẫn còn, nên bạn phải cài thêm file policy.

Tin vui là từ JDK 9 và JDK 8u161 trở đi, chính sách mặc định đã là unlimited (thuộc tính crypto.policy=unlimited trong file java.security, xem JDK-8170157). Bài gắn tag Java 21, nên trên JDK hiện đại bạn không cần cài gì thêm. Dù vậy, nếu bạn phải đóng gói thư viện hay ứng dụng chạy trên môi trường JDK 8 cũ của khách hàng mà không có quyền can thiệp vào thư mục cài đặt JVM, hoặc muốn tránh lệ thuộc vào cấu hình security provider trên máy đích, thì có hai đường: cài thêm file policy cho JVM (đơn giản nếu bạn quản lý được máy chạy), hoặc dùng bộ Lightweight API của BouncyCastle.

Các class của BouncyCastle bắt đầu bằng Jca/Jce (như JcaContentSignerBuilder) đều gọi xuống JCE provider bên dưới. Ngược lại, nhóm class bắt đầu bằng Bc (BcECContentSignerBuilder, BcDigestCalculatorProvider...) tự xử lý thuật toán trực tiếp trong thư viện mà không đi qua JCE provider, nên bỏ qua luôn rào cản policy của JVM cũ. Code ký với bộ API nhẹ này như sau:

X509Certificate certificate = ...;
PrivateKey privateKey = ...; // private key EC tương ứng với certificate
 
X509CertificateHolder x509CertificateHolder = new X509CertificateHolder(certificate.getEncoded());
String certAlgorithm = certificate.getPublicKey().getAlgorithm();
 
CMSTypedData message = new CMSProcessableByteArray(dataToSign);
 
AlgorithmIdentifier sigAlgId = new DefaultSignatureAlgorithmIdentifierFinder().find("SHA256WithECDSA");
 
AlgorithmIdentifier digAlgId = new DefaultDigestAlgorithmIdentifierFinder().find(sigAlgId);
AsymmetricKeyParameter privateKeyParameter = PrivateKeyFactory.createKey(
                                                      privateKey.getEncoded());
 
ContentSigner signer = new BcECContentSignerBuilder(sigAlgId, digAlgId).build(privateKeyParameter);
 
SignerInfoGeneratorBuilder signerInfoGeneratorBuilder =
                       new SignerInfoGeneratorBuilder(new BcDigestCalculatorProvider());
SignerInfoGenerator infoGenerator = signerInfoGeneratorBuilder.build(signer, x509CertificateHolder);
 
CMSSignedDataGenerator dataGenerator = new CMSSignedDataGenerator();
dataGenerator.addSignerInfoGenerator(infoGenerator);
 
dataGenerator.addCertificate(x509CertificateHolder);
 
CMSSignedData signedData = dataGenerator.generate(message, true);

Kết quả vẫn là một container CMS y như trên, mà không cần cài thêm bản vá nào. Xác minh thì dùng đoạn code sau:

Collection<SignerInformation> signers = cmsSignedData.getSignerInfos().getSigners();
List<SignerInformation> signerList = new ArrayList<>(signers);
SignerInformation signerFromCMS = signerList.get(0);
SignerId sid = signerFromCMS.getSID();
 
Store store = cmsSignedData.getCertificates();
Collection<X509CertificateHolder> certificateCollection = store.getMatches(sid);
ArrayList<X509CertificateHolder> x509CertificateHolders = new ArrayList<>(certificateCollection);
// we use the first certificate
X509CertificateHolder x509CertificateHolder = x509CertificateHolders.get(0);
 
BcECSignerInfoVerifierBuilder verifierBuilder = new BcECSignerInfoVerifierBuilder(
        new DefaultCMSSignatureAlgorithmNameGenerator(),
        new DefaultSignatureAlgorithmIdentifierFinder(),
        new DefaultDigestAlgorithmIdentifierFinder(),
        new BcDigestCalculatorProvider());
SignerInformationVerifier verifier = verifierBuilder.build(x509CertificateHolder);
boolean result = signerFromCMS.verify(verifier);

Có một điểm hay bị bỏ sót ở cả hai đoạn xác minh: chúng lấy certificate từ chính container để kiểm tra. verify() trả về true chỉ chứng minh dữ liệu khớp với certificate đi kèm, chứ chưa chứng minh certificate đó đáng tin. Ai cũng có thể tự tạo cặp khoá, tự cấp certificate, ký rồi gửi cho bạn. Trong hệ thống thật, bạn còn phải kiểm tra certificate: chuỗi chứng thực có dẫn về một CA hoặc certificate bạn tin không (CertPathValidator trong JDK), còn hạn không, có bị thu hồi không (CRL/OCSP). Nếu hai bên đã trao đổi public key trước thì so certificate trong container với certificate đã biết là đủ.

Nhìn lại thì tuỳ ngữ cảnh mà bạn chọn mức đóng gói phù hợp: chữ ký thô qua java.security.Signature rất gọn cho giao tiếp nội bộ khi hai đầu đã biết trước khoá và thuật toán; còn CMS container dài dòng hơn lúc khởi tạo nhưng đóng gói đầy đủ metadata để trao đổi giữa các tổ chức, và có thể chuyển sang nhánh Bc* (Lightweight API) nếu không muốn phụ thuộc vào JCE provider của máy chạy.

# lời kết

Chữ ký số giờ chẳng còn lạ gì với anh em developer, nhưng làm đúng thì vẫn phải để ý vài chỗ. Nếu chuẩn bị đưa chữ ký số vào hệ thống của mình, bạn có thể dò lại theo mấy câu hỏi này:

  • Thuật toán đang dùng còn được khuyến nghị không? Với RSA thì khoá tối thiểu 2048 bit, ưu tiên SHA256withRSA hoặc RSA-PSS; muốn chữ ký ngắn, ký nhanh thì cân nhắc ECDSA hay Ed25519 (có sẵn trong JDK từ Java 15).
  • Bên xác minh có kiểm tra certificate thật không, hay chỉ gọi verify() với certificate gửi kèm như đã nói ở trên?
  • Private key đang nằm ở đâu? Trong file trên server, trong keystore có mật khẩu, hay trong HSM/KMS? Lộ private key là mọi chữ ký từ trước tới nay đều mất giá trị.

Câu thứ hai là câu đáng kiểm tra trước. Tìm trong code mọi chỗ gọi verify(), xem certificate dùng để xác minh lấy từ đâu. Nếu nó lấy thẳng từ container mà không qua CertPathValidator hay so với certificate đã biết, sửa chỗ đó trước khi lo chuyện đổi thuật toán. Và đừng tự chế định dạng riêng rồi trông vào việc giấu cách làm: dùng chuẩn có sẵn như CMS thì bên đối tác cũng đọc được bằng thư viện của họ.

Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!

Happy coding 😎 👍🏻 🚀 🔥.

Reference: