Narzędzie do generowania i weryfikowania haseł

Generuj silne hasła i frazy hasłowe, wspieraj wsadowe generowanie, unikalność, sprawdzanie siły i zasad, a także dostęp do przykładów kodu w wielu językach i praktycznej wiedzy.

Tester strategii hasła

Hasło do testowania

Minimalna długość Wymagaj małych liter Wymagaj wielkich liter Wymagaj cyfr Wymagaj symboli Zabronij ciągów sekwencyjnych (np. abc, 123) Zabronij długich powtórzeń (np. aaaa)

Wyniki

Długość
Małe litery
Duże litery
Cyfry
Symbole
Ciągi sekwencyjne
Powtórzenia
Czarna lista

Wszystkie sprawdzenia są wykonywane lokalnie w Twojej przeglądarce.

Generator fraz hasłowych

Liczba słów

Separator

Duża pierwsza litera Dodaj liczbę

Słowa są wybierane losowo za pomocą Web Crypto. Lista demonstracyjna jest skrócona z powodu ograniczeń rozmiaru.

Szybki przewodnik po haszowaniu haseł

Argon2id

Użyj Argon2id z odpowiednio ustawionymi parametrami pamięci
Iteracje ≥ 2, pamięć ≥ 64 MB (dostosuj do środowiska)
Przechowuj unikalną sól dla każdego użytkownika; opcjonalnie stosuj pepper na poziomie aplikacji

PBKDF2

Wybierz SHA-256 lub SHA-512, iteracje ≥ 210 tys. (dostosuj do potrzeb)
Używaj unikalnej soli dla każdego hasza; obsługuje uaktualnianie parametrów
Przenoś do wyższych parametrów kosztu przy następnym logowaniu użytkownika

BCrypt

Koszt 10–14, w zależności od mocy serwera
Unikaj obcinania haseł; haszuj pełne hasła
Zastosuj limitowanie i monitorowanie punktów uwierzytelniania

Źródło: NIST SP 800-63B, OWASP ASVS. Parametry powinny być dopasowane do możliwości sprzętowych i SLO.

Ocena siły hasła

Siła jest przybliżona na podstawie entropii: entropy = log2(rozmiar puli znaków) × długość. Większa pula znaków i większa długość zwiększają odporność na próby zgadnięcia.

Słabe: < 50 bitów — tylko do użytku jednorazowego lub niskiej wartości
Średnie: 50–80 bitów — akceptowalne w scenariuszach o niskim ryzyku
Mocne: 80–110 bitów — zalecany domyślny cel
Bardzo mocne: > 110 bitów — odpowiednie dla kont administratora lub krytycznych kont

Wskazówka: Rzeczywiste modele ataku mogą się różnić; unikaj ponownego używania haseł i włącz wieloskładnikową weryfikację (MFA).

Instrukcja użytkowania

Wybierz długość i zestaw znaków (małe/duże litery/cyfry/symbole); w razie potrzeby włącz opcje „Unikaj podobnych” i „Wymagaj każdego”
Aby uzyskać bardziej szczegółową kontrolę: wyklucz konkretne znaki lub grupy znaków, albo wybierz grupy symboli
Kliknij „Generuj”; jeśli potrzebujesz wielu wyników, włącz generowanie wsadowe i skopiuj wszystkie jednym kliknięciem
Aby zweryfikować istniejące hasło, użyj „Testerze zasad”; aby wygenerować łatwą do zapamiętania frazę, użyj „Generatora fraz hasłowych”

Funkcje

Bezpieczny generator losowy (Web Crypto)
Konfigurowalne zestawy znaków i grupy symboli
Filtrowanie podobnych znaków i niestandardowe wykluczenia
Wsadowe generowanie, gwarancja unikalności i statystyki usuwania duplikatów
Ocena siły i indeks entropii
Tester zasad i generator fraz hasłowych
Przykłady kodu w wielu językach （JS、Python、PHP、Go、Java、C#、Rust）
Kopiowanie jednym kliknięciem (jedno hasło / wszystkie)

Przykłady generowania haseł

Silne (Strong)

Długość 24, zawiera duże i małe litery, cyfry i symbole

Łatwe do zapamiętania (Memorable)

Długość 16, zawiera duże i małe litery oraz cyfry, unika podobnych znaków

Baza wiedzy o hasłach

1) Siła hasła i entropia

Entropia ≈ log2(rozmiar zbioru znaków) × długość; wpływ długości jest zazwyczaj większy
Zalecany cel: konta ogólne ≥ 80 bitów; konta o wysokich uprawnieniach / finansowe ≥ 110 bitów
Większy zbiór znaków + większa długość → większa odporność na próbę zgadnięcia

2) Długość vs złożoność

Bezmyślnie dodawanie symboli jest mniej skuteczne niż zwiększenie długości
Unikaj przewidywalnych wzorców (np. zawsze „wielka litera na początku + cyfra na końcu!”)
Najpierw zapewnij wystarczającą długość, a następnie umiarkowanie zwiększaj różnorodność znaków

3) Typowe błędy i antywzorce

Sekwencje klawiatury (qwerty), powtarzające się bloki, daty urodzenia / lata — łatwo odgadnąć za pomocą reguł
"Hasło macierzyste + sufiks strony" to wariacja z powtórzeń, co tworzy skupione ryzyko i ułatwia odgadnięcie
Nie używaj tego samego hasła na wielu stronach

4) Zalecenia dotyczące zarządzania hasłami

Używaj menedżera haseł; każde hasło unikalne; dla ważnych kont włącz MFA
Unikaj przesyłania haseł w postaci jawnej przez publiczne kanały; w razie potrzeby używaj "przyjaznych dla wymowy" haseł
Jeśli wykryjesz wyciek lub powtórzenie hasła, natychmiast je zmień i zapewnij jego unikalność

5) Przewodnik po frazach-hasłach (Passphrase)

Kombinacja 4–6 słów jest często silna i łatwa do zapamiętania
Mieszanie separatorów, wielkich liter na początku i dodawanie cyfr zwiększa siłę i czytelność
Unikaj bezpośredniego łączenia popularnych fraz, tekstów piosenek lub cytат

Przewodnik po praktykach bezpieczeństwa haseł

Najlepsze praktyki

Używaj jak najdłuższych haseł: 16+ znaków dla zwykłych kont, 24+ dla krytycznych kont
Dla łatwej zapamiętania preferuj frazy hasłowe; losowe, wysokopoziomowe hasła powinny być przechowywane przez menedżera haseł
Włącz wieloczynnikową weryfikację (MFA) wszędzie, gdzie to możliwe
Nie używaj tych samych haseł na różnych witrynach — każde konto powinno mieć unikalne hasło

Entropia i siła

Entropia odzwierciedla nieprzewidywalność opartą na długości i rozmiarze puli znaków; wyższa liczba bitów entropii zazwyczaj oznacza większe bezpieczeństwo.

Zwiększaj długość hasła, aby osiągnąć największy efekt bezpieczeństwa
W miarę możliwości używaj różnych zestawów znaków
Zbyt surowe wykluczanie znaków zmniejsza pulę znaków i obniża siłę hasła

Polityki i wymiana haseł

Wolę długie hasła i czarne listy zakazujących powszechnych/ufundowanych haseł niż skomplikowane reguły składniowe
Unikaj częstego wymuszania zmian haseł; zmieniaj je tylko przy podejrzeniu naruszenia lub ryzyka
Używaj list ujawnionych haseł, aby blokować powszechne lub ujawnione hasła

Frazy hasłowe

Używaj 4–6 losowych słów połączonych separatorami, np. lake-CARROT-planet_7
Unikaj cytowania znanych zwrotów, tekstów piosenek itp.; losowość jest ważniejsza niż „spryt”
Dla krytycznych kont zaleca się używanie menedżera haseł do przechowywania prawdziwie losowych, wysokoentrpowych haseł

Wskazówki dotyczące ustawień generowania

"Require each selected set" gwarantuje, że przynajmniej jeden znak z każdej wybranej grupy będzie obecny
"Avoid similar" zwiększa czytelność, ale nieco zmniejsza rozmiar puli znaków
Znaki specjalne można ograniczyć do podzbioru akceptowanego przez system docelowy

Przechowywanie po stronie serwera

Nigdy nie przechowuj haseł w postaci jasnej; używaj silnych funkcji skrótu (Argon2id/PBKDF2/BCrypt) z solą
Odpowiednio ustaw parametry (pamięć/czas/koszt); w razie potrzeby używaj pepper
Ogranicz liczbę prób logowania i monitoruj nieudane próby; podczas ataku dodaj CAPTCHA lub weryfikację urządzenia

Wieloczynnikowa weryfikacja i odzyskiwanie

Preferuj TOTP lub klucze sprzętowe; unikaj SMS
Chron proces odzyskiwania: użyj wieloczynnikowej weryfikacji lub weryfikacji e-mail z okresem oczekiwania
Zapewnij zapasowe kody odzyskiwania i zaleć użytkownikowi ich bezpieczne przechowywanie

Ochrona przed atakami brute force

Stosuj stopniowe opóźnienia/blokady oraz oceny ryzyka IP/urządzenia
Skonfiguruj WAF/i ograniczenie przepustowości dla formularzy logowania i interfejsów API
Monitoruj ataki typu credential stuffing i zachęcaj użytkowników do używania unikalnych haseł

Lokalne przechowywanie i przetwarzanie

Przechowuj i automatycznie wypełniaj hasła za pomocą niezawodnego menedżera haseł
Nie udostępniaj haseł w postaci jawnej przez czat ani e-mail; w zespołach używaj narzędzi zarządzania sekretami
Jeśli musisz zapisywać hasła offline, upewnij się, że są fizycznie bezpieczne

Oświadczenie: Ten narzędzie generuje hasła lokalnie w przeglądarce za pomocą Web Crypto; dane nie są wysyłane na serwer.

Jak generować hasła za pomocą języków programowania

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);
}