Bộ Tạo MD5

MD5 (Message-Digest Algorithm 5) là một hàm hash mật mã được sử dụng rộng rãi tạo ra giá trị hash 128-bit (16-byte), thường được biểu diễn dưới dạng số thập lục phân 32 chữ số. Nó được thiết kế bởi Ronald Rivest vào năm 1991 để thay thế thuật toán MD4 trước đó và được quy định trong RFC 1321 vào tháng 4 năm 1992.

Mặc dù có các lỗ hổng bảo mật, MD5 vẫn thường được sử dụng cho các ứng dụng không quan trọng về bảo mật như checksum để xác minh tính toàn vẹn dữ liệu và phát hiện sự hỏng dữ liệu không chủ ý. Nó vẫn phù hợp cho các mục đích phi mật mã khác do yêu cầu tính toán thấp hơn so với các thuật toán hash bảo mật mới hơn.

MD5 được thiết kế bởi Giáo sư Ronald Rivest của MIT như một sự thay thế an toàn hơn cho MD4. Thuật toán nhận một thông điệp đầu vào có độ dài tùy ý và tạo ra một "dấu vân tay" hoặc "message digest" 128-bit làm đầu ra. Thuật toán MD5 được thiết kế khá nhanh trên máy 32-bit và không yêu cầu bảng thay thế lớn, cho phép triển khai nhỏ gọn.

Thuật toán xử lý một thông điệp có độ dài thay đổi thành một đầu ra có độ dài cố định 128 bit bằng cách chia đầu vào thành các khối 512-bit. Nó hoạt động trên trạng thái 128-bit được chia thành bốn từ 32-bit (A, B, C và D) và trải qua bốn vòng hoạt động, với mỗi vòng thực hiện 16 phép toán dựa trên các hàm phi tuyến tính, phép cộng mô-đun và xoay bit.

// Khởi tạo biến
A = 0x67452301
B = 0xEFCDAB89
C = 0x98BADCFE
D = 0x10325476

// Chuẩn bị hàm
F(X,Y,Z) = (X AND Y) OR ((NOT X) AND Z)
G(X,Y,Z) = (X AND Z) OR (Y AND (NOT Z))
H(X,Y,Z) = X XOR Y XOR Z
I(X,Y,Z) = Y XOR (X OR (NOT Z))

// Xử lý thông điệp (thông điệp phải là bội số của 512 bit)
// Đệm thông điệp cho đến khi độ dài ≡ 448 (mod 512)
// Thêm biểu diễn 64-bit của độ dài thông điệp gốc

// Vòng lặp chính
cho mỗi khối 512-bit của thông điệp đã đệm:
    // Chia khối thành mười sáu từ 32-bit (M[0..15])
    // Sao chép trạng thái khối
    AA = A
    BB = B
    CC = C
    DD = D
    
    // Vòng 1
    cho i từ 0 đến 15:
        A = B + ((A + F(B,C,D) + M[i] + T[i]) <<< s[i])
        Xoay A, B, C, D
    
    // Vòng 2
    cho i từ 16 đến 31:
        A = B + ((A + G(B,C,D) + M[(5*i + 1) mod 16] + T[i]) <<< s[i])
        Xoay A, B, C, D
    
    // Vòng 3
    cho i từ 32 đến 47:
        A = B + ((A + H(B,C,D) + M[(3*i + 5) mod 16] + T[i]) <<< s[i])
        Xoay A, B, C, D
    
    // Vòng 4
    cho i từ 48 đến 63:
        A = B + ((A + I(B,C,D) + M[(7*i) mod 16] + T[i]) <<< s[i])
        Xoay A, B, C, D
    
    // Thêm kết quả xử lý khối
    A = A + AA
    B = B + BB
    C = C + CC
    D = D + DD

// Đầu ra
MD5 = A || B || C || D // Nối thành kết quả 128-bit

Năm 1996, một lỗi được phát hiện trong thiết kế của MD5, mặc dù lúc đó không được coi là nghiêm trọng. Đến năm 2004, các lỗ hổng nghiêm trọng hơn được tìm thấy, và các nhà nghiên cứu đã chứng minh các cuộc tấn công va chạm thực tế - phương pháp tạo ra các cặp đầu vào khác nhau tạo ra cùng một giá trị hash MD5.

Năm 2008, một nhóm các nhà nghiên cứu đã sử dụng những lỗ hổng này để tạo ra một chứng chỉ SSL giả mạo trông có vẻ hợp pháp. Phần mềm độc hại Flame đã khai thác điểm yếu của MD5 để giả mạo chữ ký số của Microsoft vào năm 2012. Các cuộc tấn công va chạm hiện đại có thể tìm thấy va chạm MD5 trong vài giây trên phần cứng máy tính tiêu chuẩn.