Instrument de generare și verificare a parolelor

Generează parole puternice și fraze de parolă, cu suport pentru validare în loturi, unicitate, intensitate și strategii, împreună cu exemple de cod în mai multe limbi și cunoștințe utile.

Tester de politică de parolă

Parola de testat

Lungime minimă Cere litere mici Cere litere mari Cere cifre Cere simboluri Interzice secvențe consecutive (ex: abc, 123) Interzice repetiții prea lungi (ex: aaaa)

Rezultate

Lungime
Litere mici
Litere mari
Cifre
Simboluri
Secvențe consecutive
Repetări
Listă neagră

Toate verificările sunt efectuate local în browserul dumneavoastră.

Generator de fraze-parolă

Număr de cuvinte

Separator

Literă mare la început Adaugă un număr

Cuvintele sunt selectate folosind un generator aleatoriu sigur (Web Crypto). Lista de cuvinte din demo este limitată din motive de volum.

Tabel de referință pentru hash-uri de parolă

Argon2id

Folosește Argon2id cu parametrii de memorie potriviți
Iterații ≥ 2, memorie ≥ 64MB (ajustează în funcție de mediu)
Stochează sârma unică per utilizator; opțional folosește pepper la nivel aplicație

PBKDF2

Alege SHA-256 sau SHA-512, iteratii ≥ 210k (ajustează în funcție de nevoi)
Folosește o sârmă unică pentru fiecare hash; suportă actualizarea parametrilor
Migrează la parametri mai costisitori la următoarea autentificare a utilizatorului

BCrypt

Cost între 10–14, în funcție de capacitățile serverului
Evită problemele de trunchiere; aplică hash pe parola completă
Aplică limitare și monitorizare la endpoint-urile de autentificare

Referință: NIST SP 800-63B, OWASP ASVS. Parametrii trebuie să corespundă capacităților hardware și SLO.

Evaluare a puterii parolei

Puterea este estimată pe baza entropiei: entropy = log2(dimensiunea_poolului_de_caractere) × lungime. Un pool mai mare de caractere și o lungime mai mare cresc rezistența la încercări de ghicire.

Slabă: < 50 biți — potrivită doar pentru scenarii temporare / cu valoare scăzută
Medie: 50–80 biți — acceptabilă în scenarii cu risc scăzut
Puternică: 80–110 biți — obiectiv recomandat implicit
Foarte puternică: > 110 biți — recomandată pentru conturi de administrator / critice

Sfat: Modelele reale de atac pot varia; evitați reutilizarea parolelor și activați autentificarea cu doi factori (MFA).

Instrucțiuni de utilizare

Alege lungimea și setul de caractere (Lower/Upper/Digits/Symbols); activează opțiunile „Evită caractere similare” și „Require each” dacă este necesar
Pentru control mai fin: exclud caractere sau grupuri de caractere, sau selectează grupuri de simboluri
Apasă pe „Generează”; pentru mai multe rezultate, activează generarea în lot și copiază toate cu un singur clic
Pentru a verifica o parolă existentă, folosește „Testerul de strategie”; pentru o frază de parolă ușor de reținut, folosește „Generatorul de fraze de parolă”

Funcționalități

Sursă aleatoare sigură (Web Crypto)
Seturi de caractere și grupuri de simboluri configurabile
Filtrare caractere similare și excludere personalizată
Generare în lot, asigurarea unicității și statistică de eliminare a duplicatelor
Indici de intensitate și entropie
Tester de strategie și generator de fraze de parolă
Exemple de cod în mai multe limbi （JS、Python、PHP、Go、Java、C#、Rust）
Copiere cu un singur clic (singură parolă / toate)

Exemple de generare a parolelor

Puternică (Strong)

Lungime 24, include litere mari/mici/cifre/simboluri

Ușor de reținut (Memorable)

Lungime 16, include litere mari/mici/cifre, evită caractere similare

Bază de cunoștințe despre parole

1) Forța parolei și entropia

Entropia ≈ log2(mărimea setului de caractere) × lungime; contribuția lungimii este de obicei mai mare
Recomandare: conturi obișnuite ≥ 80 biți; conturi cu privilegii ridicate/financiare ≥ 110 biți
Un set de caractere mai mare + o lungime mai mare → rezistență sporită la încercări de ghicire

2) Lungime vs complexitate

Adăugarea arbitrară de simboluri este mai puțin eficientă decât creșterea lungimii
Evitați modele fixe și previzibile (de exemplu, întotdeauna „literă mare la început + cifră la sfârșit!”)
Asigurați-vă mai întâi o lungime suficientă, apoi creșteți ușor diversitatea caracterelor

3) Greșeli frecvente și anti-modeluri

Secvențe de tastatură (qwerty), blocuri repetitive, date de naștere/anuri — ușor de ghicit prin reguli
"Parolă principală + sufix site" este o variantă reutilizată, cu risc concentrat și ușor de prezis
Nu folosiți aceeași parolă pe mai multe site-uri

4) Recomandări pentru gestionarea parolelor

Folosiți un manager de parole; fiecare site să aibă o parolă unică; activați MFA pentru conturile importante
Evitați transmiterea parolelor în text clar pe canale publice; în cazuri necesare, utilizați parole "prietenoase din punct de vedere fonetic"
Dacă descoperiți o scurgere sau reutilizare, schimbați imediat parola și asigurați-vă că este unică

5) Ghid pentru passphrase-uri

Combinări de 4–6 cuvinte sunt de obicei puternice și ușor de memorat
Combinați delimitatori diferiți, litere mari la începutul cuvintelor și adăugați cifre pentru a crește forța și lizibilitatea
Evitați conectarea directă a frazelor, versurilor sau citatelor populare

Ghid practic privind securitatea parolelor

Cele mai bune practici

Utilizați lungimi suficient de mari: 16+ caractere pentru conturi obișnuite, 24+ pentru conturile critice
Pentru memorare, preferați frazele de parolă; pentru parole aleatoare și puternice, folosiți un manager de parole
Activati cât mai mult posibil autentificarea cu mai mulți factori (MFA)
Nu reutilizați parolele pe site-uri diferite; fiecare cont trebuie să aibă o parolă unică

Entropie și forță

Entropia măsoară imprevizibilitatea bazată pe lungime și dimensiunea setului de caractere; cu cât numărul de biți de entropie este mai mare, cu atât parola este mai puternică.

Creșteți lungimea pentru a obține cea mai mare îmbunătățire
Folosiți seturi multiple de caractere, dacă este posibil
Excluderea excesivă a caracterelor reduce setul disponibil și scade puterea

Politici și schimbare periodică

Preferați regulile de lungime și liste negre de parole comune/compromisate în loc de reguli complexe de compoziție
Evitați schimbarea obligatorie frecventă; schimbați doar în caz de compromitere sau risc
Folosiți liste de parole compromisate pentru a bloca parolele comune/compromisate

Fraze de parolă

Folosiți 4–6 cuvinte aleatoare conectate prin delimitatori, de exemplu: lake-CARROT-planet_7
Evitați frazele cunoscute din citate, texte de cântece etc.; aleatorietatea este mai importantă decât 'inteligenta'
Pentru conturile critice, recomandăm utilizarea unui manager de parole pentru a stoca parole aleatoare cu entropie ridicată

Sfaturi pentru configurarea generării

"Require each selected set" asigură că cel puțin un caracter din fiecare set este prezent
"Avoid similar" crește lizibilitatea, dar micșorează ușor dimensiunea setului de caractere
Simbolurile pot fi limitate la submulțimea acceptată de sistemul țintă

Stocare la nivel de server

Nu stocați niciodată parolele în text clar; folosiți hash-uri puternice (Argon2id/PBKDF2/BCrypt) cu salt
Setați parametrii corect (memorie/timp/cost); utilizați pepper dacă este necesar
Limitați viteza de încercare și monitorizați încercările eșuate; în caz de atac, adăugați CAPTCHA sau verificare dispozitiv

Autentificare cu mai mulți factori și recuperare

Preferați TOTP/chei hardware; evitați cât mai mult posibil SMS-ul
Protejați procesul de recuperare: folosiți autentificare multi-factor sau verificare prin e-mail, cu perioadă de întârziere
Ofertați coduri de recuperare de rezervă și încurajați utilizatorii să le păstreze în siguranță

Protecție împotriva atacurilor brute force

Folosiți întârzieri progresive/ blocări și scoruri de risc bazate pe IP/dispozitiv
Configurați WAF/limitare de rate pentru API-uri și formulare de autentificare
Monitorizați atacurile de tip credential stuffing și încurajați utilizatorii să folosească parole unice

Stocare și procesare locală

Folosiți un manager de parole de încredere pentru stocare și completare automată
Nu trimiteți parolele în text clar prin chat sau e-mail; folosiți instrumente de gestionare a secretelor pentru echipe
Dacă trebuie să le scrieți manual, asigurați-vă că sunt păstrate fizic în siguranță

Declarație: Acest instrument generează parole local în browser folosind Web Crypto; nu trimite nicio dată către server.

Cum să generezi parole prin limbaje de programare

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