Công cụ Tạo và Kiểm tra Mật khẩu

Tạo mật khẩu mạnh và cụm mật khẩu, hỗ trợ kiểm tra hàng loạt, tính duy nhất, độ mạnh và chính sách, đồng thời cung cấp ví dụ mã nguồn đa ngôn ngữ và kiến thức thực dụng.

Bộ kiểm tra chính sách mật khẩu

Mật khẩu cần kiểm tra

Độ dài tối thiểu Yêu cầu chữ thường Yêu cầu chữ hoa Yêu cầu chữ số Yêu cầu ký tự đặc biệt Cấm mẫu liên tiếp (ví dụ: abc, 123) Cấm lặp lại quá dài (ví dụ: aaaa)

Kết quả

Độ dài
Chữ thường
Chữ hoa
Chữ số
Ký tự đặc biệt
Dãy liên tiếp
Lặp lại
Danh sách cấm

Tất cả các kiểm tra đều được thực hiện ngay trên trình duyệt của bạn.

Bộ tạo cụm mật khẩu

Số từ

Ký tự phân cách

Viết hoa chữ cái đầu Thêm số

Các từ được chọn ngẫu nhiên an toàn bằng Web Crypto. Danh sách từ trong bản demo bị giới hạn về dung lượng.

Bảng tra cứu nhanh băm mật khẩu

Argon2id

Sử dụng Argon2id với tham số bộ nhớ phù hợp
Thời gian ≥ 2 vòng lặp, bộ nhớ ≥ 64MB (tùy chỉnh theo môi trường)
Sử dụng salt riêng cho từng người dùng; có thể bổ sung pepper ở cấp ứng dụng

PBKDF2

Chọn SHA-256 hoặc SHA-512, số lần lặp ≥ 210k (tùy chỉnh theo nhu cầu)
Sử dụng salt duy nhất cho mỗi băm; hỗ trợ nâng cấp tham số
Chuyển đổi sang tham số chi phí cao hơn khi người dùng đăng nhập lần tới

BCrypt

Chi phí từ 10–14, tùy thuộc vào khả năng máy chủ
Tránh vấn đề cắt ngắn; luôn băm toàn bộ mật khẩu
Áp dụng giới hạn tốc độ và giám sát cho endpoint xác thực

Tham khảo: NIST SP 800-63B, OWASP ASVS. Các tham số cần phù hợp với khả năng phần cứng và SLO.

Đánh giá độ mạnh mật khẩu

Độ mạnh được ước tính dựa trên entropy: entropy = log2(kích thước bộ ký tự) × độ dài. Bộ ký tự lớn hơn và độ dài lớn hơn sẽ tăng khả năng chống đoán mò.

Yếu: < 50 bit —— Chỉ phù hợp cho cảnh sử dụng một lần hoặc ít quan trọng
Trung bình: 50–80 bit —— Có thể chấp nhận trong môi trường rủi ro thấp
Mạnh: 80–110 bit —— Mục tiêu mặc định được khuyến nghị
Rất mạnh: > 110 bit —— Phù hợp cho tài khoản quản trị viên hoặc quan trọng

Gợi ý: Các mô hình tấn công thực tế có thể khác biệt; hãy tránh dùng lại mật khẩu và kích hoạt xác thực đa yếu tố (MFA).

Hướng dẫn sử dụng

Chọn độ dài và bộ ký tự (Chữ thường/Chữ hoa/Số/Ký hiệu); tùy chọn bật 'Tránh ký tự tương tự' và 'Yêu cầu mỗi loại'
Khi cần kiểm soát chi tiết hơn: Loại trừ ký tự/khối ký tự hoặc chọn nhóm ký hiệu
Nhấn tạo; nếu cần nhiều kết quả, bật chế độ tạo hàng loạt và sao chép tất cả chỉ với một cú nhấp
Để kiểm tra mật khẩu hiện có, dùng 'Bộ kiểm tra chính sách'; để tạo cụm mật khẩu dễ nhớ, dùng 'Bộ tạo cụm mật khẩu'

Tính năng nổi bật

Nguồn ngẫu nhiên an toàn (Web Crypto)
Bộ ký tự và nhóm ký hiệu có thể cấu hình
Lọc ký tự tương tự và loại trừ tùy chỉnh
Tạo hàng loạt, đảm bảo tính duy nhất và thống kê loại bỏ trùng lặp
Đánh giá độ mạnh và chỉ số entropy
Bộ kiểm tra chính sách và bộ tạo cụm mật khẩu
Ví dụ mã nguồn đa ngôn ngữ （JS、Python、PHP、Go、Java、C#、Rust）
Sao chép một lần (một dòng/tất cả)

Ví dụ tạo mật khẩu

Mạnh (Strong)

Độ dài 24, bao gồm chữ hoa/thường/ chữ số/ký tự đặc biệt

Dễ nhớ (Memorable)

Độ dài 16, bao gồm chữ hoa/thường/chữ số, tránh ký tự tương tự

Thư viện kiến thức mật khẩu

1) Độ mạnh mật khẩu và độ ngẫu nhiên

Độ ngẫu nhiên ≈ log2(kích thước bộ ký tự) × độ dài; độ dài thường đóng góp nhiều hơn
Mục tiêu đề xuất: Tài khoản thông thường ≥ 80 bit; tài khoản có quyền cao/tài chính ≥ 110 bit
Bộ ký tự lớn hơn + độ dài dài hơn → chống đoán tốt hơn

2) Độ dài vs Độ phức tạp

Việc thêm vô tội vạ các ký tự đặc biệt ít hiệu quả hơn so với tăng độ dài
Tránh các mẫu dự đoán được (ví dụ: luôn viết hoa chữ cái đầu + kết thúc bằng số!)
Ưu tiên đảm bảo độ dài đủ, sau đó mới tăng nhẹ tính đa dạng của ký tự

3) Các sai lầm phổ biến và mô hình phản tác dụng

Các chuỗi bàn phím (qwerty), khối lặp lại, ngày sinh/năm sinh... dễ bị phát hiện bởi quy tắc
"Mật khẩu gốc + hậu tố trang web" là sự tái sử dụng biến thể, rủi ro tập trung và dễ bị đoán
Không nên dùng cùng một mật khẩu cho nhiều trang web

4) Gợi ý quản lý mật khẩu

Sử dụng trình quản lý mật khẩu; mỗi trang một mật khẩu duy nhất; kích hoạt MFA cho tài khoản quan trọng
Tránh truyền mật khẩu dưới dạng văn bản rõ qua kênh công cộng; nếu cần, hãy dùng mật khẩu dễ phát âm
Nếu phát hiện rò rỉ hoặc tái sử dụng, thay đổi ngay lập tức và đảm bảo tính duy nhất

5) Hướng dẫn về cụm mật khẩu (Passphrase)

Kết hợp nhiều từ (4–6 từ) thường mạnh và dễ nhớ
Kết hợp dấu phân cách, viết hoa chữ cái đầu, chèn số để tăng cường độ mạnh và khả năng đọc hiểu
Tránh ghép trực tiếp các cụm phổ biến/lời bài hát/trích dẫn nổi tiếng

Hướng dẫn thực hành bảo mật mật khẩu

Thực hành Tốt Nhất

Ưu tiên độ dài đủ lớn: tài khoản thông thường 16+ ký tự, tài khoản quan trọng 24+ ký tự
Đối với nhu cầu ghi nhớ, hãy ưu tiên sử dụng cụm mật khẩu; mật khẩu ngẫu nhiên mạnh nên được lưu bởi trình quản lý mật khẩu
Bật xác thực đa yếu tố (MFA) khi có thể
Không tái sử dụng mật khẩu giữa các trang web; mỗi tài khoản phải có mật khẩu duy nhất

Độ Entropy và Độ Mạnh

Độ entropy phản ánh mức độ không thể dự đoán dựa trên độ dài và kích thước tập ký tự; số bit entropy càng cao thì mật khẩu thường càng mạnh.

Tăng độ dài để đạt lợi ích tối đa
Sử dụng nhiều bộ ký tự khi có thể
Loại bỏ quá nhiều ký tự sẽ thu hẹp tập ký tự và làm giảm độ mạnh

Chính sách và Thay Đổi Định Kỳ

Ưu tiên độ dài và danh sách cấm các mật khẩu phổ biến/bị rò rỉ thay vì các quy tắc phức tạp về thành phần
Tránh thay đổi mật khẩu thường xuyên; chỉ thay đổi khi xảy ra rò rỉ hoặc có nguy cơ
Sử dụng danh sách mật khẩu bị rò rỉ để ngăn chặn các mật khẩu phổ biến/bị rò rỉ

Cụm Mật Khẩu

Sử dụng 4–6 từ ngẫu nhiên nối với nhau bằng ký tự phân cách, ví dụ: lake-CARROT-planet_7
Tránh sử dụng câu nổi tiếng/ lời bài hát hoặc cụm phổ biến; tính ngẫu nhiên quan trọng hơn sự 'thông minh'
Đối với tài khoản quan trọng, hãy sử dụng trình quản lý mật khẩu để lưu trữ mật khẩu ngẫu nhiên có độ entropy cao thực sự

Gợi ý Cài Đặt Tạo Mật Khẩu

"Require each selected set" đảm bảo mỗi loại ký tự xuất hiện ít nhất một lần
"Avoid similar" cải thiện khả năng đọc, nhưng làm giảm nhẹ kích thước tập ký tự
Ký tự đặc biệt có thể giới hạn ở tập con được hệ thống mục tiêu chấp nhận

Lưu Trữ Phía Máy Chủ

Không bao giờ lưu mật khẩu dưới dạng văn bản rõ; hãy dùng hàm băm mạnh (Argon2id/PBKDF2/BCrypt) kèm salt
Thiết lập tham số hợp lý (bộ nhớ/thời gian/chi phí); sử dụng pepper khi cần thiết
Giới hạn tốc độ và giám sát các nỗ lực đăng nhập thất bại; khi bị tấn công, thêm CAPTCHA hoặc xác minh thiết bị

Xác Thực Đa Yếu Tố và Phục Hồi

Ưu tiên TOTP/ khóa phần cứng; tránh sử dụng SMS nếu có thể
Bảo vệ quy trình khôi phục: dùng xác thực đa yếu tố hoặc xác minh email kèm thời gian chờ
Cung cấp mã khôi phục dự phòng và khuyến nghị người dùng lưu giữ cẩn thận

Ngăn Chặn Tấn Công Bạo Lực

Sử dụng độ trễ tăng dần/ khóa và đánh giá rủi ro IP/thiết bị
Cấu hình WAF/ giới hạn tốc độ cho API và biểu mẫu đăng nhập
Theo dõi các cuộc tấn công dọn dẹp (credential stuffing) và khuyến khích người dùng sử dụng mật khẩu duy nhất

Lưu Trữ và Xử Lý Tại Địa Phương

Sử dụng trình quản lý mật khẩu đáng tin cậy để lưu trữ và điền tự động
Không chia sẻ mật khẩu dưới dạng văn bản rõ qua trò chuyện/ email; nhóm nên dùng công cụ quản lý bí mật
Nếu cần ghi lại thủ công, hãy đảm bảo an toàn vật lý

Thông báo: Công cụ này tạo mật khẩu cục bộ trong trình duyệt bằng Web Crypto; không gửi dữ liệu nào đến máy chủ.

Cách tạo mật khẩu thông qua các ngôn ngữ lập trình

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

import (
  "crypto/rand"
  "math/big"
)

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}