L'attacco della forza bruta — operazione completa

Documento di riferimento del progetto Time2Crack
Recipienti: sviluppatori, ricercatori di sicurezza, utenti avanzati

Contenuto

  • Panoramica
  • Sfondo storico e accademico
  • Matematica: Keyspace e entropia
  • Architettura di un attacco brutale forza moderna
  • Velocità di calcolo dell'algoritmo di hash
  • Rilevamento Tanket in Time2Crack
  • Calcolo del tempo di cracking: rawTime()
  • Riduzione della data rilevata: rilevaDateAndReduce()
  • Guardia monotonicia: pavimento di altri attacchi
  • Calibrazione HF e ruolo della forza lorda
  • Confronto con altri attacchi
  • Limitazioni teoretiche e pratiche
  • Che forza bruta non dice
  • Efficace difesa
  • Referenze

  • 1. Panoramica

    La forza cruda è l'attacco più fondamentale in cracking password: si compone di test sistematicamente tutte le combinazioni possibili Nessuna intelligenza, nessuna euristica — solo la potenza di calcolo raw contro le dimensioni dello spazio per viaggiare.

    Nel Time2Crack, la forza bruta gioca un duplice ruolo:

  • Attacco modellato Rappresenta il tempo teorico massimo che un aggressore avrebbe messo, assumendo nessun'altra vulnerabilità sfruttabile.
  • Piano (monotonicity guard) : serve come terminale più basso per tutti gli altri attacchi — nessun attacco specializzato può legittimamente mostrare un tempo inferiore a quello che prenderebbe la forza cruda sul sottocatena alfabetico della password.
  • In pratica, la forza cruda non è quasi mai l'attacco più veloce su una vera password umana — PCFG, Markov o attacco ibrido sarà più efficace. Ma per una password veramente casuale e lunga, rappresenta la realtà: l'attaccante non ha altra scelta che navigare lo spazio esaustivamente.

    2. Sfondo storico e accademico

    2.1 Origini

    La forza cruda precede il computer: il principio di testare tutte le possibili combinazioni viene utilizzato fin dalle prime macchine di crittografia meccanica (Enigma durante la seconda guerra mondiale). La bomba di Alan Turing era, in senso lato, un dispositivo di forza cruda forzato da un'ipotesi di presepi.

    Con l'avvento dei computer, la forza password unix è stata formalizzata dagli anni '70 agli anni '80:

    AnnoEvento
    ----------------
    1979Morris & Thompson: Primo articolo accademico sulla sicurezza delle password Unix, con l'analisi delle forze crude su /etc/passwd
    1988Morris Worm: prima impresa di massa utilizzando, tra le altre cose, un dizionario e una forza cruda crepa password
    1993Crack 5.0 (Alec Muffett): primo strumento di cracking pubblico da forza grezza su Unix
    2004Ophcrack: tabelle di scanalatura + forza grezza su LM/NTLM hashes Windows
    2007GPU-accelerated cracking (Elcomsoft): primo uso pubblico della GPU per accelerare la forza lorda
    2012Hashcat open source: strumento di riferimento, massima operazione GPU
    2016Hive Systems: pubblicazione annuale delle tabelle "gross force by GPU" diventa riferimento industriale

    2.2 Benchmarks

    La rivoluzione della GPU ha cambiato l'ordine di grandezza della forza grezzo. Su CPU, un attaccante degli anni '90 ha testato ~10.000 password MD5/second. 168,9 miliardi al secondo — un'accelerazione di 16 milioni di volte in 30 anni.

    Principali fonti accademiche :

    3. Basi matematiche: keyspace e entropia

    3.1 Spazio chiave

    Keyspace (keyspace) è il numero totale di possibili password per una data lunghezza e serbatoio:

    keyspace = charset_size ^ length

    Esempi:

    CaricamentoDimensioneLunghezzaSpazio chiaveValutazione
    ----------------------------------------------
    cifre singole108108 = 100.000- 108
    Minuscoli da soli26.8268 milioni di euro~2 × 1011
    Alfanumerologia628628 milioni~2 × 1014
    ASCII completo958958 miliardi~6 × 1015
    ASCII completo95129512 - 5.4 × 1023~5 × 1023
    ASCII completo95169516 - 4.4 × 1031~4 × 1031

    3.2 entropia binaria

    Entropia (misurata in bit) è la formulazione logaritmica dello spazio chiave:

    entropie = length × log₂(charset_size)

    In Time2Crack (funzione entropy())

    function entropy(pw) {
      return pw.length * Math.log2(getCharset(pw).size);
    }

    Il rapporto tra entropia e keyspace:

    keyspace = 2^entropie
    entropie = log₂(keyspace)
    Esempi concreti :
    PasswordCaricamentoLunghezzaEntropiaSpazio chiave
    ---------------------------------------------
    "12345678"10 (digits)826.6 bit108
    "password"26 (più basso)837.6 bit268
    Password162 (alfano)953.6 bit629
    "P@ssw0rd!"95 (completa ASCII)959.3 bit959
    xQz7@mK9#2pL95 (completa ASCII)1279 bit9512

    3.3 Speranza matematica: Keyspace / 2

    La forza cruda non sempre prova keyspace Combinazioni Integer — in media, trova la password a metà strada, in quanto l'obiettivo è equiprobabilmente distribuito nello spazio.aspettativa matematica il numero di tentativi è quindi:

    tentatives_attendues = keyspace / 2

    Questo è esattamente ciò che modelli bruteTime() in Time2Crack:

    // "For brute force: expected value is keyspace/2 (uniform random search)"
    function bruteTime(keyspace, rate) {
      const ls = Math.log(keyspace / 2) - Math.log(rate);
      return Math.exp(ls); // = (keyspace / 2) / rate
    }

    Questa divisione di 2 è corretta secondo l'ipotesi che l'attaccante viaggi lo spazio linearmente (non ripetitivo). keyspace/2 Tentativi.


    14. Efficace difesa

    14.1 lato utente: lunghezza e casualità

    La forza lorda è sconfitta da due fattori combinati:

    Lunghezza : ogni carattere aggiuntivo moltiplica lo spazio chiave per charset_sizeDa 8 a 12 caratteri (charset 95) moltiplica lo spazio chiave per 954 - 81 milioni.
    Vero casuale : un generatore crittografico sicuro (CSPRNG) produce password che non beneficiano di alcuna riduzione probabilistica.
    Raccomandazione pratica :

    14.2 lato server: algoritmi resistenti

    La scelta dell'algoritmo hash moltiplica o divide il tempo di forza cruda per fattori fino a diversi milioni :

    RaccomandazioneAlgoritmoMotivazione
    ---------------------------
    ConsigliatoArgon2idMemory-hard, GPU resistente
    Consigliatobcrypt (costo ≥ 12)Intenzionalmente lento, salato
    AccettabileCrittografiaMemoria dura ma meno standardizzata
    InadeguatoSHA-256 salatoTroppo veloce anche con sale
    PericolosoMD5, SHA-1, NTLMNon salato, estremamente veloce

    15. Riferimenti biblici

    Accademica

    Morris, R., & Thompson, K. (1979). Sicurezza della password: Una storia del caso. Comunicazioni dell'ACM, 22(11), 594-597. → Articolo fondatore sulla sicurezza di password Unix
    Sprengers, M. (2011). Monitoraggio password basato su GPU (le tesi di Master). Radboud University Nijmegen. → formalizzazione matematica di cracking GPU, benchmark su GPU singolo
    Wheeler, D.L. (2016). zxcvbn: stima della forza della password a basso costo. 25 ° Simposio di sicurezza USENIX. → Dati sullo spazio chiave efficace (Tabella 2: -30% per password strutturate)
    Dürmuth, M. et al. (2015). OMEN: Ordine Markov ENumerator. ESORICS 2015. → Riferimento comparativo per terminali probabilistici vs forza lorda

    Industria

    Hive Systems. (2025). 2025 Hive Systems Password Table. https://www.hivesystems.io/password-table → benchmark annuali su 12× RTX 4090, riferimento standard
    Gosney, J (2012). 8x Nvidia GTX 1080 Hashcat benchmarks. GitHub Gist. → Primo riferimento pubblico multi-GPU, riferimento storico
    Hashcat. (2024). Punti di riferimento ufficiali Hashcat v6.2.6. https://hashcat.net/hashcat/ → Velocità ufficiali per algoritmo, fonte di costanti Time2Crack
    NIST SP 800-63B. (2017, aggiornato 2024). Linee guida per l'identità digitale: autenticazione e gestione del ciclo di vita. → Raccomandazioni ufficiali sulla lunghezza e la complessità delle password
    OWASP. (2024). Scheda di deposito della password. https://cheatssheetseries.owasp.org/cheatssheets/Password Storage Cheat Sheet.html → Raccomandazioni su bcrypt (costo ≥ 12), Argon2id come standard moderni
    Documento generato per il progetto Time2Crack — ultimo aggiornamento: 2026-04-18 Sulla base dell'implementazione in app.js, funzioni grezzeTime(), getCharset(), e guardia monotonicity