Lewati ke konten
🛠️ToolsShed

Penguji Kebijakan Kata Sandi

Uji kata sandi terhadap aturan kebijakan yang dapat dikonfigurasi.

Aturan Kebijakan

Tentang alat ini

Pengujian kebijakan kata sandi adalah alat yang memvalidasi kata sandi terhadap aturan keamanan yang dapat dikonfigurasi untuk memastikan bahwa kata sandi memenuhi persyaratan spesifik organisasi atau aplikasi Anda. Daripada menebak apakah kata sandi cukup kuat, alat ini memeriksa terhadap beberapa kriteria: panjang minimum, aturan kompleksitas (huruf besar, huruf kecil, angka, simbol), dan daftar hitam kata-kata terlarang. Dengan memahami aturan mana yang dipenuhi atau tidak dipenuhi kata sandi, Anda dapat memperkuat kata sandi yang lemah dan memastikan standar keamanan yang konsisten di seluruh sistem Anda.

Menggunakan pengujian sangat sederhana: masukkan kata sandi Anda dan sesuaikan aturan kebijakan yang penting bagi Anda. Tetapkan persyaratan panjang minimum, aktifkan dan nonaktifkan aturan kompleksitas, dan tambahkan kata-kata atau pola terlarang yang tidak boleh muncul dalam kata sandi. Alat menampilkan secara instan aturan mana yang dipenuhi kata sandi Anda dan mana yang tidak, memberikan umpan balik visual langsung. Ini sangat berguna bagi pengembang yang membangun sistem autentikasi, administrator IT yang menerapkan kebijakan kata sandi perusahaan, dan siapa pun yang perlu memvalidasi kata sandi sebelum penerapan atau pendaftaran pengguna.

Kebijakan kata sandi adalah batu loncatan keamanan siber, dan konteks yang berbeda memerlukan aturan yang berbeda—PIN sederhana berbeda dari kata sandi perusahaan, yang berbeda dari kunci kriptografi. Pengujian ini membantu Anda menjelajahi pertukaran antara kekuatan keamanan dan kegunaan, serta memahami mengapa aturan tertentu penting. Baik Anda merancang kebijakan kata sandi untuk tim, melatih pengguna pada standar keamanan, atau hanya penasaran tentang evaluasi kekuatan kata sandi, alat ini mengungkap aturan di balik autentikasi yang aman.

Pertanyaan yang Sering Diajukan

Implementasi Kode

import re
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class PasswordPolicy:
    min_length: int = 8
    max_length: int = 128
    require_uppercase: bool = True
    require_lowercase: bool = True
    require_digit: bool = True
    require_symbol: bool = True
    min_unique_chars: int = 5
    forbidden_patterns: list[str] = field(default_factory=lambda: [
        r"(..)\1{2,}",       # repeated two-char block 3+ times
        r"(.)\1{3,}",         # same char 4+ times in a row
        r"(?i)password",       # literal word "password"
        r"(?i)qwerty",
    ])
    symbol_chars: str = r"!@#$%^&*()-_=+[]{}|;':",./<>?"

@dataclass
class PolicyResult:
    passed: bool
    violations: list[str] = field(default_factory=list)
    score: int = 0  # 0-100

def check_password(password: str, policy: Optional[PasswordPolicy] = None) -> PolicyResult:
    if policy is None:
        policy = PasswordPolicy()

    violations: list[str] = []
    score = 0

    # Length checks
    if len(password) < policy.min_length:
        violations.append(f"Too short: minimum {policy.min_length} characters")
    elif len(password) >= policy.min_length:
        score += 25

    if len(password) > policy.max_length:
        violations.append(f"Too long: maximum {policy.max_length} characters")

    # Character class checks
    if policy.require_uppercase and not re.search(r"[A-Z]", password):
        violations.append("Must contain at least one uppercase letter")
    else:
        score += 15

    if policy.require_lowercase and not re.search(r"[a-z]", password):
        violations.append("Must contain at least one lowercase letter")
    else:
        score += 15

    if policy.require_digit and not re.search(r"\d", password):
        violations.append("Must contain at least one digit")
    else:
        score += 15

    if policy.require_symbol and not re.search(
        f"[{re.escape(policy.symbol_chars)}]", password
    ):
        violations.append("Must contain at least one symbol")
    else:
        score += 15

    # Unique characters
    if len(set(password)) < policy.min_unique_chars:
        violations.append(f"Must use at least {policy.min_unique_chars} different characters")
    else:
        score += 15

    # Forbidden patterns
    for pattern in policy.forbidden_patterns:
        if re.search(pattern, password):
            violations.append(f"Contains forbidden pattern: {pattern}")

    passed = len(violations) == 0
    return PolicyResult(passed=passed, violations=violations, score=min(score, 100))


# Example usage
if __name__ == "__main__":
    tests = ["abc", "Password1!", "C0rrectH0rseBatteryStaple!"]
    policy = PasswordPolicy(min_length=12)
    for pwd in tests:
        result = check_password(pwd, policy)
        print(f"{pwd!r}: passed={result.passed}, score={result.score}")
        for v in result.violations:
            print(f"  - {v}")

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.