ToolDeck

ตัวสร้างรหัสผ่าน

สร้างรหัสผ่านสุ่มที่แข็งแกร่งด้วยความยาวและชุดอักขระที่กำหนดเอง

ความยาว20
จำนวน5

เครื่องมือสร้างรหัสผ่านคืออะไร?

เครื่องมือสร้างรหัสผ่านจะสร้างสตริงอักขระแบบสุ่มเพื่อใช้เป็นรหัสผ่านสำหรับบัญชีผู้ใช้ API keys ข้อมูลรับรองฐานข้อมูล และค่าลับสำหรับการเข้ารหัส ต่างจากรหัสผ่านที่มนุษย์เลือกเอง รหัสผ่านที่สร้างขึ้นจะดึงจากพื้นที่การรวมกันของอักขระที่เป็นไปได้ทั้งหมด ทำให้ต้านทานการโจมตีแบบ dictionary attack และการเดาจากรูปแบบได้ เครื่องมือนี้สร้างรหัสผ่านแบบสุ่มที่แข็งแกร่งออนไลน์โดยใช้ตัวสร้างเลขสุ่มแบบเข้ารหัสที่มีอยู่ในเบราว์เซอร์ของคุณ

ความแข็งแกร่งของรหัสผ่านขึ้นอยู่กับสองปัจจัย ได้แก่ ความยาวและความหลากหลายของอักขระ รหัสผ่านความยาว 20 อักขระที่ใช้ตัวพิมพ์ใหญ่ ตัวพิมพ์เล็ก ตัวเลข และสัญลักษณ์มีเอนโทรปีประมาณ 131 บิต ที่ระดับนั้นการโจมตีแบบ brute-force ที่ทดสอบหนึ่งล้านล้านการเดาต่อวินาทีจะใช้เวลานานกว่าอายุจักรวาลเพื่อลองทุกรูปแบบ สูตรคำนวณตรงไปตรงมา: entropy = length x log2(charset size)

มาตรฐานอย่าง NIST SP 800-63B แนะนำรหัสผ่านที่มีความยาวอย่างน้อย 8 อักขระโดยไม่มีขีดจำกัดบนที่บังคับใช้โดยผู้ตรวจสอบ และไม่สนับสนุนกฎการประกอบแบบบังคับ เช่น กำหนดให้มีสัญลักษณ์หนึ่งตัวพอดี โดยให้ความสำคัญกับ passphrase ที่ยาวกว่าแทน สำหรับข้อมูลรับรองแบบ machine-to-machine และ service account อักขระสุ่มตั้งแต่ 20 ตัวขึ้นไปจากชุดอักขระครบชุดถือเป็นมาตรฐานขั้นต่ำที่ยอมรับได้ในกรอบงานความปลอดภัยและระบบการปฏิบัติตามข้อกำหนดส่วนใหญ่

ทำไมต้องใช้เครื่องมือสร้างรหัสผ่าน?

มนุษย์สร้างตัวเลขสุ่มได้ไม่ดีนัก เราใช้รหัสผ่านซ้ำ เลือกคำจากพจนานุกรม แทนที่ตัวอักษรด้วยรูปแบบที่คาดเดาได้ (@ แทน a, 3 แทน e) และมักใช้สตริงสั้น เครื่องมือสร้างรหัสผ่านช่วยขจัดอคติของมนุษย์ออกจากกระบวนการ

🔐
สร้างโดยให้ความเป็นส่วนตัวเป็นอันดับแรก
รหัสผ่านถูกสร้างทั้งหมดในเบราว์เซอร์ของคุณโดยใช้ Web Crypto API ไม่มีอักขระใดออกจากอุปกรณ์ของคุณ ไม่มีการบันทึกข้อมูล และไม่มีการส่งคำขอเครือข่ายระหว่างการสร้าง
ผลลัพธ์แบบกลุ่มทันที
สร้างรหัสผ่านได้สูงสุด 20 รายการในครั้งเดียวด้วยการคลิกเพียงครั้งเดียว คัดลอกรหัสผ่านทีละรายการหรือทั้งหมดพร้อมกันสำหรับสคริปต์การจัดเตรียมหรือที่เก็บข้อมูลรับรอง
🛡️
ไม่ต้องมีบัญชี
ไม่ต้องสมัครสมาชิก ไม่ต้องใช้อีเมล ไม่มีคุกกี้ติดตามรหัสผ่านที่สร้างขึ้น เปิดหน้า กำหนดตัวเลือก แล้วสร้างได้เลย
🎛️
ควบคุมชุดอักขระได้อย่างสมบูรณ์
เปิดหรือปิดตัวพิมพ์ใหญ่ ตัวพิมพ์เล็ก ตัวเลข และสัญลักษณ์ได้อย่างอิสระ ตั้งความยาวตั้งแต่ 4 ถึง 128 อักขระเพื่อให้ตรงตามข้อกำหนดของระบบหรือนโยบายใด ๆ

กรณีการใช้งานเครื่องมือสร้างรหัสผ่าน

การพัฒนา Frontend
สร้างรหัสผ่านทดสอบสำหรับการตรวจสอบฟอร์ม การทดสอบความยาวอินพุต และการพัฒนากระบวนการยืนยันตัวตน ตรวจสอบว่าฟอร์มล็อกอินของคุณจัดการรหัสผ่านความยาว 128 อักขระและอักขระพิเศษได้อย่างถูกต้อง
Backend และ DevOps
สร้างข้อมูลรับรองฐานข้อมูล API token และรหัสผ่าน service account ระหว่างการตั้งค่าโครงสร้างพื้นฐาน ใช้การสร้างแบบกลุ่มเพื่อจัดเตรียมบริการหลายรายการในเซสชันเดียว
วิศวกรรมความปลอดภัย
สร้างค่าลับที่มีเอนโทรปีสูงสำหรับคีย์เข้ารหัส การลงนาม HMAC และการหมุนเวียนค่าลับ JWT ตั้งความยาวที่ 64 อักขระขึ้นไปสำหรับค่าลับที่ต้องมีเอนโทรปีเกิน 256 บิต
QA และการทดสอบการเจาะระบบ
ทดสอบการบังคับใช้นโยบายรหัสผ่านโดยการสร้างสตริงที่รวมหรือไม่รวมชุดอักขระเฉพาะ ตรวจสอบว่าระบบปฏิเสธรหัสผ่านที่ต่ำกว่าความยาวขั้นต่ำหรือความซับซ้อนได้อย่างถูกต้อง
วิศวกรรมข้อมูล
สร้างข้อมูลรับรองแบบสุ่มสำหรับสภาพแวดล้อมทดสอบ ฐานข้อมูล staging และค่าลับของ CI/CD pipeline หลีกเลี่ยงการนำรหัสผ่านที่ใช้งานจริงมาใช้ซ้ำในข้อมูลทดสอบโดยสร้างรหัสผ่านใหม่ต่อสภาพแวดล้อม
ความปลอดภัยของบัญชีส่วนตัว
สร้างรหัสผ่านเฉพาะสำหรับแต่ละบัญชีออนไลน์ ใช้เครื่องมือนี้ร่วมกับตัวจัดการรหัสผ่านเพื่อจัดเก็บข้อมูลรับรองที่คุณไม่จำเป็นต้องจดจำ

ตารางอ้างอิงเอนโทรปีรหัสผ่าน

เอนโทรปีวัดว่ารหัสผ่านคาดเดาได้ยากแค่ไหน คำนวณจาก log2(charset_size ^ length) เอนโทรปีที่สูงขึ้นหมายถึงรูปแบบที่เป็นไปได้มากขึ้นสำหรับผู้โจมตีในการค้นหา NIST และ OWASP แนะนำเอนโทรปีอย่างน้อย 80 บิตสำหรับแอปพลิเคชันที่มีความปลอดภัยสูง

ความยาวชุดอักขระเอนโทรปีเวลา Brute-Force
8lower + digits~41 bitsMinutes to hours
12lower + upper + digits~71 bitsCenturies (offline)
16all character sets~105 bitsBeyond brute-force
20all character sets~131 bitsBeyond brute-force
32all character sets~210 bitsBeyond brute-force
64all character sets~419 bitsBeyond brute-force

เวลาที่ใช้ถอดรหัสสมมติว่ามีการเดา 1 ล้านล้านครั้งต่อวินาที (การโจมตีแบบออฟไลน์ด้วย GPU สมัยใหม่) การโจมตีออนไลน์ที่มีการจำกัดอัตราจะช้ากว่านี้หลายระดับ

CSPRNG เทียบกับ Math.random() สำหรับการสร้างรหัสผ่าน

แหล่งที่มาของความสุ่มมีความสำคัญพอ ๆ กับความยาวรหัสผ่าน รหัสผ่านที่สร้างด้วยตัวสร้างเลขสุ่มที่คาดเดาได้สามารถถูกสร้างใหม่โดยผู้โจมตีที่รู้จักอัลกอริทึมและสถานะ seed เครื่องมือนี้ใช้ crypto.getRandomValues() ซึ่งเป็น CSPRNG ที่มีอยู่ในเบราว์เซอร์สมัยใหม่ทุกตัว

crypto.getRandomValues()
ใช้แหล่งเอนโทรปีของระบบปฏิบัติการ (hardware RNG, interrupt timing เป็นต้น) ผลลัพธ์ไม่สามารถคาดเดาได้แม้ผู้โจมตีจะรู้ผลลัพธ์ก่อนหน้าทั้งหมด กำหนดโดยข้อกำหนด W3C Web Crypto สำหรับการดำเนินการที่ต้องการความปลอดภัย
Math.random()
ใช้อัลกอริทึมแบบกำหนดได้ที่ seed จากพูลเอนโทรปีที่จำกัด ผลลัพธ์สามารถคาดเดาได้หากทราบสถานะ seed ข้อกำหนด ECMAScript ระบุชัดเจนว่า Math.random() ไม่ให้เลขสุ่มที่ปลอดภัยทางการเข้ารหัส ห้ามใช้สำหรับการสร้างรหัสผ่าน

ตัวอย่างโค้ด

สร้างรหัสผ่านแบบโปรแกรมในภาษาต่าง ๆ ทุกตัวอย่างด้านล่างใช้แหล่งเลขสุ่มที่ปลอดภัยทางการเข้ารหัส ไม่ใช่ Math.random() หรือ PRNG ที่ไม่แข็งแกร่งเทียบเท่า

JavaScript (Web Crypto API)
// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"
Python
import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)
CLI (OpenSSL / /dev/urandom)
# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols
Go
package main

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

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

คำถามที่พบบ่อย

รหัสผ่านควรยาวแค่ไหน?
สำหรับบัญชีผู้ใช้ 16 อักขระจากชุดอักขระแบบผสมให้เอนโทรปีมากกว่า 100 บิต ซึ่งเพียงพอสำหรับโมเดลภัยคุกคามปัจจุบันทั้งหมด สำหรับค่าลับของเครื่อง (API keys, คีย์เข้ารหัส) ใช้ 32 อักขระหรือมากกว่า NIST SP 800-63B กำหนดขั้นต่ำ 8 อักขระแต่แนะนำให้ระบบอนุญาตรหัสผ่านที่ยาวกว่ามากโดยไม่ตัดทอน
เครื่องมือสร้างรหัสผ่านนี้ปลอดภัยในการใช้งานหรือไม่?
ใช่ รหัสผ่านถูกสร้างในเบราว์เซอร์ของคุณโดยใช้ Web Crypto API (crypto.getRandomValues) ไม่มีข้อมูลถูกส่งไปยังเซิร์ฟเวอร์ใด ๆ คุณสามารถตรวจสอบได้โดยเปิดแท็บเครือข่ายของเบราว์เซอร์และสังเกตว่าไม่มีคำขอใดถูกส่งเมื่อคุณคลิกสร้าง ซอร์สโค้ดเป็น JavaScript ฝั่งไคลเอนต์ที่มองเห็นได้ใน developer tools ของเบราว์เซอร์
เอนโทรปีรหัสผ่านคืออะไร?
เอนโทรปีคือการวัดความสุ่มที่แสดงเป็นบิต รหัสผ่านที่มีเอนโทรปี N บิตมีค่าที่เป็นไปได้ 2^N ค่า เช่น รหัสผ่านความยาว 20 อักขระที่ดึงมาจากอักขระ ASCII ที่พิมพ์ได้ 95 ตัวมีเอนโทรปี log2(95^20) = 131.1 บิต แต่ละบิตเพิ่มเติมจะทำให้จำนวนการเดาที่ผู้โจมตีต้องใช้เพิ่มเป็นสองเท่า
ควรรวมสัญลักษณ์ในรหัสผ่านหรือไม่?
การรวมสัญลักษณ์จะเพิ่มชุดอักขระจาก 62 (ตัวอักษร + ตัวเลข) เป็น 95 (ASCII ที่พิมพ์ได้) ซึ่งเพิ่มเอนโทรปีประมาณ 6.1 บิตต่ออักขระ บางระบบจำกัดสัญลักษณ์ที่อนุญาต หากระบบปฏิเสธสัญลักษณ์บางตัว ให้ปิดตัวเลือกสัญลักษณ์และชดเชยด้วยรหัสผ่านที่ยาวขึ้น รหัสผ่านตัวอักษรและตัวเลข 24 อักขระมีเอนโทรปีมากกว่ารหัสผ่าน 16 อักขระที่มีสัญลักษณ์
ทำไมไม่ใช้ Math.random() สร้างรหัสผ่าน?
Math.random() ไม่ปลอดภัยทางการเข้ารหัส JavaScript engine ส่วนใหญ่ใช้ xorshift128+ หรือ PRNG ที่เร็วคล้ายกันซึ่งออกแบบมาสำหรับการจำลองและเกม ไม่ใช่ความปลอดภัย ผู้โจมตีที่สังเกตผลลัพธ์สองสามรายการสามารถกู้คืนสถานะภายในและคาดเดาผลลัพธ์ในอนาคตทั้งหมดได้ Web Crypto API ใช้แหล่งเอนโทรปีของระบบปฏิบัติการที่ไม่สามารถคาดเดาได้
ฉันสามารถใช้รหัสผ่านที่สร้างขึ้นสำหรับ API keys และ token ได้หรือไม่?
ได้ แต่ควรพิจารณาข้อกำหนดรูปแบบของระบบเป้าหมาย API บางตัวคาดหวัง key ที่เข้ารหัส base64 หรือ hex string แทนที่อักขระแบบสุ่ม สำหรับการสร้างค่าลับแบบดิบ ใช้ชุดอักขระครบชุดที่ 32 อักขระขึ้นไป สำหรับ key แบบ base64 ให้สร้างไบต์สุ่มและเข้ารหัสแยกต่างหากแทนที่จะถือว่า base64 เป็นชุดอักขระรหัสผ่าน
ควรหมุนเวียนรหัสผ่านบ่อยแค่ไหน?
NIST SP 800-63B (2017, อัปเดต 2024) ไม่แนะนำให้บังคับหมุนเวียนรหัสผ่านผู้ใช้เป็นระยะ เนื่องจากส่งผลให้เลือกรหัสผ่านที่อ่อนแอกว่า ให้หมุนเวียนเฉพาะเมื่อมีหลักฐานการถูกบุกรุกเท่านั้น สำหรับค่าลับของเครื่องและ service account ให้หมุนเวียนตามโมเดลความเสี่ยงขององค์กร โดยทั่วไปทุก 90 วันสำหรับข้อมูลรับรองที่มีสิทธิ์สูง

เครื่องมือที่เกี่ยวข้อง

เครื่องนับคำนับคำ ตัวอักษร ประโยค ย่อหน้า และประมาณเวลาอ่านตัวแปลง Caseแปลงข้อความระหว่าง uppercase, lowercase, title case, camelCase, snake_case และรูปแบบอื่นๆเครื่องมือสร้าง Lorem Ipsumสร้างข้อความตัวอย่าง Lorem Ipsum โดยกำหนดจำนวนย่อหน้าและคำได้ตัวเรียงบรรทัดเรียงบรรทัดตามตัวอักษร ตามความยาว ย้อนกลับ หรือสุ่มลำดับบรรทัดตัวลบบรรทัดซ้ำลบบรรทัดที่ซ้ำกันออกจากข้อความ เก็บไว้เฉพาะบรรทัดที่ไม่ซ้ำกันเปรียบเทียบข้อความเปรียบเทียบข้อความสองอย่างแบบเคียงข้างและเน้นความแตกต่างบรรทัดต่อบรรทัดตัวทดสอบ Regexทดสอบ regular expressions กับข้อความและดูผลการจับคู่ที่เน้นสีทั้งหมดดูตัวอย่าง Markdownดูตัวอย่างข้อความ Markdown ที่แสดงผลเป็น HTML แบบเรียลไทม์ตัวสร้าง URL Slugแปลงข้อความใดๆ เป็น slug ที่สะอาดและเป็นมิตรต่อ URL