Pular para o conteúdo
🛠️ToolsShed

Testador de Política de Senhas

Teste senhas contra regras de política configuráveis.

Regras de Política

Sobre esta ferramenta

Um testador de política de senha é uma ferramenta que valida senhas contra regras de segurança configuráveis para garantir que atendam aos requisitos específicos da sua organização ou aplicativo. Em vez de adivinhar se uma senha é forte o suficiente, esta ferramenta a verifica contra múltiplos critérios—comprimento mínimo, regras de complexidade (maiúsculas, minúsculas, números, símbolos) e listas negras de palavras proibidas. Ao entender quais regras uma senha passa ou falha, você pode fortalecer senhas fracas e garantir padrões de segurança consistentes em seus sistemas.

Usar o testador é simples: insira sua senha e personalize as regras de política que importam para você. Defina requisitos de comprimento mínimo, alterne regras de complexidade ligadas e desligadas, e adicione palavras ou padrões proibidos que nunca devem aparecer em senhas. A ferramenta mostra instantaneamente quais regras sua senha atende e quais falha, fornecendo feedback visual imediato. Isso é particularmente útil para desenvolvedores que constroem sistemas de autenticação, administradores de TI que aplicam políticas corporativas de senhas, e qualquer pessoa que precise validar senhas antes da implantação ou inscrição de usuários.

Políticas de senha são a pedra angular da cibersegurança, e contextos diferentes exigem regras diferentes—um PIN simples difere de uma senha corporativa, que difere de uma chave criptográfica. Este testador o ajuda a explorar o equilíbrio entre força de segurança e usabilidade, e a compreender por que certas regras importam. Quer você esteja projetando uma política de senha para sua equipe, treinando usuários em padrões de segurança, ou simplesmente curioso sobre avaliação de força de senha, esta ferramenta desmistifica as regras por trás da autenticação segura.

Perguntas Frequentes

Implementação de Código

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.