Trình tạo Hash SHA-384

SHA-384 Hashing là gì?

SHA-384 là hàm băm mật mã được định nghĩa trong NIST FIPS 180-4 thuộc họ SHA-2. Hàm này chấp nhận đầu vào có độ dài tùy ý và tạo ra message digest cố định 384-bit (48 byte), thường hiển thị dưới dạng chuỗi thập lục phân 96 ký tự. SHA-384 được sử dụng rộng rãi trong các bộ mã hóa TLS, chữ ký chứng chỉ số và các hệ thống chính phủ đòi hỏi biên độ kháng va chạm cao hơn so với SHA-256.

Về mặt nội bộ, SHA-384 là một biến thể rút gọn của SHA-512. Hàm này sử dụng cùng kích thước khối 1024-bit, 80 vòng nén và phép toán từ 64-bit như SHA-512, nhưng khởi tạo với một tập giá trị băm ban đầu khác (dẫn xuất từ các số nguyên tố thứ 9 đến thứ 16) và chỉ xuất ra 384-bit đầu tiên của trạng thái cuối. Sự rút gọn này có nghĩa là SHA-384 tạo ra digest khác với SHA-512 cho cùng một đầu vào, dù chia sẻ cùng thuật toán lõi.

Vì SHA-384 hoạt động trên các từ 64-bit, hàm này chạy nhanh hơn SHA-256 trên các bộ xử lý 64-bit hiện đại trong khi tạo ra digest lớn hơn. Điều này tạo nên một điểm cân bằng thực tế: mạnh hơn SHA-256 (kháng va chạm 192-bit so với 128-bit) mà không có chi phí lưu trữ của đầu ra hex 128 ký tự của SHA-512. SHA-384 là hàm băm mặc định cho chữ ký xác minh chứng chỉ TLS 1.3 và được yêu cầu bởi NSA Suite B (nay là CNSA) cho dữ liệu TỐI MẬT.

Tại sao dùng công cụ tạo SHA-384 trực tuyến?

Thông thường, tạo giá trị băm SHA-384 đòi hỏi lệnh terminal hoặc viết code. Công cụ trên trình duyệt này cho phép bạn tính toán digest SHA-384 ngay lập tức mà không cần cài đặt bất cứ thứ gì hoặc gửi dữ liệu đến máy chủ. Dù bạn cần tạo hash SRI cho tài nguyên CDN, xác minh checksum tệp hay so sánh đầu ra SHA-384 với SHA-256 cho cùng một đầu vào, công cụ này cung cấp cách làm việc với digest SHA-384 ngay lập tức, không phụ thuộc vào thư viện bên ngoài.

Các trường hợp sử dụng công cụ tạo Hash SHA-384

So sánh các biến thể họ SHA-2

SHA-384 thuộc họ SHA-2 cùng với nhiều biến thể khác. Bảng dưới đây cho thấy chúng khác nhau như thế nào về kích thước digest, độ dài đầu ra và các ứng dụng điển hình.

SHA-384 so với SHA-256 vs SHA-512 vs SHA-3-384

Việc lựa chọn giữa SHA-384 và các thuật toán băm khác phụ thuộc vào yêu cầu bảo mật, ràng buộc nền tảng và nhu cầu hiệu suất của bạn. Bảng so sánh này bao gồm các thuộc tính quan trọng nhất.

SHA-384 hoạt động bên trong như thế nào?

SHA-384 xử lý đầu vào thông qua cấu trúc Merkle–Damgård giống như SHA-512. Đầu vào được đệm thành bội số của 1024-bit, chia thành các khối, và mỗi khối được xử lý qua 80 vòng trộn sử dụng các hàm Ch, Maj và hai hàm Sigma với phép toán từ 64-bit. Điểm khác biệt chính so với SHA-512 là các giá trị băm ban đầu: SHA-384 sử dụng các giá trị dẫn xuất từ phần thập phân của căn bậc hai của các số nguyên tố thứ 9 đến thứ 16, trong khi SHA-512 sử dụng 8 số nguyên tố đầu tiên. Sau khi xử lý tất cả các khối, SHA-384 rút gọn trạng thái nội bộ 512-bit xuống còn 384-bit đầu tiên.

Sự rút gọn và khởi tạo khác nhau có nghĩa là SHA-384 và SHA-512 luôn tạo ra các digest khác nhau cho cùng một đầu vào. Điều này cũng khiến SHA-384 vốn dĩ kháng các cuộc tấn công mở rộng độ dài, không giống SHA-256 và SHA-512 nơi kẻ tấn công có thể thêm dữ liệu và tính toán hash hợp lệ mà không cần biết thông điệp gốc.

Ví dụ code SHA-384

SHA-384 được hỗ trợ nguyên bản trong tất cả các ngôn ngữ và môi trường thực thi chính. Dưới đây là các ví dụ hoạt động mà bạn có thể sao chép trực tiếp vào dự án của mình.

// Works in all modern browsers and Node.js 18+
async function sha384(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-384', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha384('hello world')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha384').update('hello world').digest('hex')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

import hashlib

# Basic SHA-384 hash
result = hashlib.sha384(b'hello world').hexdigest()
print(result)
# → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

# Hash a string with Unicode characters
text = 'café ☕'
hashlib.sha384(text.encode('utf-8')).hexdigest()
# → 96-character hex string

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha384()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha512"
    "fmt"
)

func main() {
    data := []byte("hello world")
    // SHA-384 lives in the crypto/sha512 package
    hash := sha512.Sum384(data)
    fmt.Printf("%x\n", hash)
    // → fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
}

# Using sha384sum (Linux)
echo -n "hello world" | sha384sum
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# macOS
echo -n "hello world" | shasum -a 384
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha384
# → SHA2-384(stdin)= fdbd8e75a67f29f701a4e040385e2e23986303ea...

# Verify a file checksum
sha384sum myfile.bin > checksum.txt
sha384sum -c checksum.txt
# → myfile.bin: OK

Câu hỏi thường gặp