Jelszó generáló és ellenőrző eszköz

Erős jelszavak és jelszófrázisok generálása, támogatva a kötegelt, egyedi, erősség- és stratégia-ellenőrzést, valamint többnyelvű kódpéldákkal és hasznos tudást.

Jelszó stratégia tesztelő

Tesztelendő jelszó

Minimális hossz Kisbetűk kötelezőek Nagybetűk kötelezőek Számok kötelezőek Szimbólumok kötelezőek Folytonos minták tiltása (pl. abc, 123) Hosszú ismétlődések tiltása (pl. aaaa)

Eredmények

Hossz
Kisbetűk
Nagybetűk
Számok
Szimbólumok
Folytonos sorozatok
Ismétlődések
Letiltott lista

Minden ellenőrzés a böngésződben helyben történik.

Jelszómondat generátor

Szavak száma

Elválasztó

Nagy kezdőbetű Szám hozzáadása

A szavak biztonságos véletlenszerű (Web Crypto) módon lettek kiválasztva. A bemutató szólista méretkorlátozás miatt rövid.

Jelszó-hash gyorsreferencia

Argon2id

Argon2id használata, ésszerű memóriaigény beállításával
Legalább 2 iteráció, memória ≥ 64 MB (környezettől függően optimalizálva)
Külön só minden felhasználó számára; opcionalisan pepper alkalmazási rétegben

PBKDF2

SHA-256 vagy SHA-512 választása, legalább 210 ezer iteráció (szükség szerint optimalizálva)
Minden hash-hez egyedi só; paraméterek frissítésének támogatása
A felhasználó következő belépésekor átmenet a magasabb költségű paraméterekre

BCrypt

Költség 10–14, a kiszolgáló képességei alapján
Elkerülendő a jelszó vágása; a teljes jelszó hash-elése
Az autentikációs végpontokon forgalomkorlátozás és figyelés

Forrás: NIST SP 800-63B, OWASP ASVS. A paramétereknek összeegyeztethetők kell legyenek a hardverrel és a SLO-val.

Jelszó erősség értékelése

Az erősség közelítőleg az entrópiából származik: entropy = log2( karakterkészlet mérete) × hossz. Nagyobb karakterkészlet és hosszabb jelszó növeli a kitalálás elleni ellenálló képességet.

Gyenge: < 50 bit —— Csak ideiglenes/kevésbé fontos használatra alkalmas
Átlagos: 50–80 bit —— Elfogadható alacsony kockázatú környezetben
Erős: 80–110 bit —— Ajánlott alapértelmezett cél
Kiváló: > 110 bit —— Adminisztrátori vagy kulcsfontosságú fiókokhoz ajánlott

Tipp: A valós támadási modellek eltérhetnek; kerülje a jelszavak újrahasznosítását, és engedélyezze a többtényezős hitelesítést (MFA).

Használati útmutató

Válassza ki a hosszúságot és a karakterkészletet (kisbetű/nyomtatott betű/számok/szimbólumok); szükség esetén engedélyezze az 'Elkerülés hasonlók' és 'Minden típus szükséges' opciót
Részletesebb vezérléshez: zárja ki a karaktereket vagy karaktercsoportokat, vagy válasszon szimbólumcsoportot
Kattintson a generálásra; ha több eredményt szeretne, engedélyezze a kötegelt generálást, és másolja ki az összes eredményt egy gombnyomással
Ha meglévő jelszót szeretne ellenőrizni, használja a 'Stratégia tesztelőt'; ha emlékezetes jelszófrázist szeretne, használja a 'Jelszófrázis generátort'

Funkciók

Biztonságos véletlenszám-generátor (Web Crypto)
Konfigurálható karakterkészletek és szimbólumcsoportok
Hasonló karakterek szűrése és egyéni kizárás
Kötegelt generálás, egyediség garantálása és duplikátumok számlálása
Erősség és entrópia mérőszámok
Stratégia tesztelő és jelszófrázis generátor
Többnyelvű kódpéldák （JS、Python、PHP、Go、Java、C#、Rust）
Egy gombnyomásra másolás (egy darab / mind)

Jelszógenerálás példák

Erős (Strong)

Hossz: 24, nagy- és kisbetűk, számok, szimbólumok

Emlékezetes (Memorable)

Hossz: 16, nagy- és kisbetűk, számok, hasonló karakterek kizárva

Jelszó tudásbázis

1) Jelszóerő és entrópia

Entrópia ≈ log2(karakterkészlet mérete) × hossz; a hossz közvetlenül nagyobb hatással van
Ajánlott cél: átlagos fiók ≥ 80 bit; magas jogosultságú/finanszírozási fiók ≥ 110 bit
Nagyobb karakterkészlet + hosszabb hossz → jobb ellenállás a kitalálásra

2) Hossz vs. összetettség

A szimbólumok ömlesztése kevésbé hatékony, mint a hossz növelése
Kerülje az előre meghatározott, kiszámítható mintázatokat (pl. mindig 'nagybetűvel kezdve + végén szám!')
Először biztosítsa elég hosszúságot, majd mérsékelten növelje a karakterek sokféleségét

3) Gyakori hibák és antipatternek

Billentyűzeti sorozatok (qwerty), ismétlődő blokkok, születési dátumok/évek könnyen kitalálhatók szabályokkal
„Alapjelszó + webhely utótag” variáns használata kockázatot koncentrál, és könnyen kitalálható
Ne használja ugyanazt a jelszót több weboldalon

4) Jelszókezelési ajánlások

Használjon jelszókezelőt; minden oldalon egyedi jelszót; fontos fiókoknál aktiválja a MFA-t
Ne küldje nyílt szövegként közös csatornákon; ha szükséges, használjon 'hangszerű' jelszavakat
Ha felfedezte a szivárgást vagy újrahasználatot, azonnal cserélje le, és biztosítsa az egyediséget

5) Jelszómondat (Passphrase) útmutató

Több szóból álló kombinációk (4–6 szó) általában erősek és könnyen emlékezhetők
Keverje össze a elválasztójeleket, nagybetűket és számokat a bennük való erő és olvashatóság növelésére
Ne használjon közismert mondatokat, dalokat vagy idézeteket közvetlenül

Jelszóbiztonsági ajánlások

Legjobb gyakorlatok

Minimálisan 16 karakteres jelszót használjon általános fiókokhoz, kulcsfontosságú fiókokhoz pedig 24+ karaktert.
Emlékezetbe vételekhez elsődlegesen mondatjelszavakat használjon; véletlenszerű, erős jelszavakat jelszókezelővel tároljon.
Amennyire lehetséges, aktiválja a többtényezős hitelesítést (MFA).
Ne ismételje meg ugyanazt a jelszót különböző weboldalakon; minden fióknak egyedi jelszóval kell rendelkeznie.

Entrópia és erősség

Az entrópia a hosszúság és a karakterkészlet mérete alapján méri az előre nem láthatóságot; magasabb bitérték általában nagyobb erősséget jelent.

A legnagyobb nyereséget a hosszúság növelésével érheti el.
Lehetséges esetekben használjon több karakterkészletet is.
Túlzott karakterkiiktatás csökkenti a karakterkészlet méretét és így az erősséget.

Politikák és cserék

A bonyolult összetételi szabályok helyett inkább a hosszúságra és a gyakori/naprakész jelszavak tiltására koncentráljon.
Ne kényszerítse a gyakori jelszóváltást; csak adatvesztés vagy kockázat esetén változtassa meg.
Használjon naprakész jelszólistát a gyakori/naprakész jelszavak blokkolására.

Mondatjelszavak

Használjon 4–6 véletlenszerű szót, amelyeket elválasztó karakterekkel kapcsoljon össze, például: lake-CARROT-planet_7
Kerülje a híres mondásokat, dalszövegeket vagy más gyakori kifejezéseket; a véletlenszerűség fontosabb, mint az 'okos' megoldás.
Kulcsfontosságú fiókokhoz javasolt a jelszókezelő segítségével való tárolás, amely valóban magas entrópiájú, véletlenszerű jelszavakat generál.

Generálási beállítások tippek

A „Require each selected set” lehetőség biztosítja, hogy minden kiválasztott kategóriából legalább egy karakter szerepeljen.
A „Avoid similar” opció javítja az olvashatóságot, de kissé csökkenti a karakterkészlet méretét.
A szimbólumokat korlátozhatja a célrendszer által elfogadott részhalmazra.

Szerveroldali tárolás

Soha ne tárolja nyílt szövegként; használjon erős hash-elést (Argon2id/PBKDF2/BCrypt) sózással.
Állítsa be megfelelően a paramétereket (memória/idő/költség), és szükség esetén használjon pepper-t.
Korlátozza a kérési sebességet, és figyelje a sikertelen próbálkozásokat; támadás esetén használjon CAPTCHA-t vagy eszközellenőrzést.

Többtényezős hitelesítés és visszaállítás

Előnyben részesítse a TOTP-t vagy hardveres kulcsot; kerülje az SMS-t, amennyire csak lehetséges.
Védje a visszaállítási folyamatot: többtényezős vagy e-mail ellenőrzés + hűvösfázis beállítása.
Biztosítson háttérbeli visszaállító kódokat, és javasolja a felhasználóknak, hogy gondosan tartsák őket.

Erőszakos támadások elleni védelem

Használjon progresszív késleltetést / zárolást és IP/eszköz kockázati pontozást.
Konfiguráljon WAF-t és sávszélesség-korlátozást API-k és bejelentkezési űrlapok számára.
Figyelje a tömeges jelszópróbákat, és ösztönözze a felhasználókat arra, hogy egyedi jelszavakat használjanak.

Helyi tárolás és feldolgozás

Biztonságos jelszókezelőt használjon a tároláshoz és automatikus kitöltéshez.
Ne osszon meg jelszavakat nyílt szövegben chaten vagy e-mailen; csapatoknál titkos kezelő eszközöket használjanak.
Ha offline jegyzetet készít, győződjön meg róla, hogy fizikailag biztonságos.

Nyilatkozat: Ez az eszköz a böngészőben helyileg használja a Web Crypto-t a jelszavak generálásához; adatokat nem küld a szerverre.

Jelszavak generálása programozási nyelveken keresztül

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