Hybride aanval

Projectreferentiedocument Time2Crack
Ontvangers: ontwikkelaars, security onderzoekers, geavanceerde gebruikers

Inhoud

  • Overzicht
  • Historische en academische achtergrond
  • Conceptuele Stichtingen: Waarom de Hybride Werken
  • Architectuur van een moderne hybride aanval
  • Het spel van mutatieregels
  • Best64 regels: het referentiespel
  • Volledige taxonomie van transformaties
  • Frequentieprioriteit: het hart van efficiëntie
  • Uitvoering in Time2Crack: addHybridAttacks()
  • De drie hybride sleutelruimtes en hun rechtvaardiging
  • Kwalificatie van hoge trouw
  • Relatie met afgeleide aanvallen
  • Benchmarks per hash-algoritme
  • Concrete voorbeelden van hybride kraken
  • Hybride aanvalslimieten
  • Doeltreffende verdediging
  • Referenties

  • 1. Overzicht

    Hybride aanval is de kraakmethode die combineert een woordenboekwoordenlijst met een reeks transformatieregelsIn plaats van elk woord te testen in het woordenboek zoals het is (pure woordenboek aanval), genereert het op de vlieg alle plausibele varianten van elk woord "kapitalisaties, karakter substituties, prefix/suffix toevoegingen, inversies .. en systematisch testen ze.

    Waarom is het zo effectief? Mensen kiezen niet voor "wachtwoord" als wachtwoord, ze kiezen voor "Password1," "p@ssw0rd," "PASSWORD123" of "wachtwoord!". Deze varianten lijken sterker omdat ze niet in de ruwe woordenboeklijst staan, maar ze behoren tot de eersten die worden gegenereerd door een modern hybride kraakgereedschap. De aanvaller gebruikt precies dezelfde "veilige" heuristieken die de gebruiker toepast.

    Hybride aanval is historisch gezien de verantwoordelijke methode voor de meerderheid van de echte "gemiddelde" wachtwoord kraakt die lijken te zijn sterk zonder sterk te zijn. (2014, IEEE S&P), de eerste 8 tot 10 regels toegepast op een huidig woord volstaan om het mediane wachtwoord te kraken bevolking.

    In Time2Crack modelde de hybride aanval:

  • De detectie dat het wachtwoord is of is afgeleid van een woordenboekwoord
  • Schatting van het aantal kandidaten dat een aanvaller moet testen alvorens de exacte variant te vinden
  • Berekening van de overeenkomstige tijd volgens het hash-algoritme van het doel

  • 2. Historische en academische achtergrond

    2.1 Oorsprong: John the Ripper en mutatieregels

    De hybride aanval is formeel geboren met John de Ripper (Solar Designer, 1996), de eerste publieke tool om een woordenlijst te combineren met een configureerbare regel engine. Voorafgaand aan John de Ripper, woordenboek aanvallen getest rauwe woorden; John introduceerde het idee dat elk woord genereert een familie van kandidaten.

    Chronologie van mijlpalen :
    JaarGebeurtenis
    1979Morris & Thompson: gebruikers vervangen letters om hun wachtwoorden te "veiligen"
    1996John the Ripper 1.0: eerste publieke regel engine, JtR syntax (:, c, u, r, d...)
    2000Alec Muffett documenteert dat 80% van het echte kraken door wordlist+regels gaat, niet brute kracht
    2006Hashcat 0,01: migratie op GPU, regels gaan van 1M→1000M kandidaten / seconde
    2009RockYou: 14.3M duidelijke wachtwoorden maken empirische kalibratie van de meest effectieve regels mogelijk
    2012Gosney (Passwordscon): 8 GPU GTX 580, best64 regels, crack 90% LinkedIn in < 6 dagen
    2013Löfstrand: publiceert "best64.rule," 64 regels voor 85-90% van de huidige menselijke transformaties
    2014Ma et al. (IEEE S&P): eerste academische studie waarin de effectiviteit wordt gekwantificeerd op regelschaal
    2016Hashcat open source: geïntegreerde best64, MD5 snelheid 2 TH/s op 8× GTX 1080
    2019Hashcat 6.0: OneRegleToRegleThemAll spel (52k regels) gegenereerd door ML op corpus van wachtwoorden
    2023NSA Advisory: beveelt expliciet het testen van bedrijfswachtwoorden met hybride tools aan

    2.2 Oprichting van empirische studies

    Klein (1990) Weir et al. (2009, IEEE S&P) Het PCFG model wordt voorgesteld maar geldig door de manier waarop de hashcat regels betrekking hebben op 78% van de transformaties waargenomen in RockYou. Demonstreert dat de wachtwoorden "Password1" en "P@ssw0rd" behoren tot de eerste 100 kandidaten gegenereerd door best64 op het woord "wachtwoord." Ma et al. (2014, IEEE S&P) De meest geciteerde studie over de effectiviteit van hybride regels.
  • Regels 1
  • Regels 1
  • Regels 1500: scheur 88%
  • Belangrijkste conclusie De eerste tien regels maken het grootste deel van het werk.
  • Durmuth et al. (2015, ESORICS) Evalueert de JtR vs Hashcat vs PCFG regels. Concludes dat de Hashcat best64 regels zijn empirisch de meest effectieve voor waargenomen duidelijke wachtwoorden, overtreffen PCFG door 12% op RockYou cover.

    2.3 LinkedIn vlucht als schoolzaak

    De 2012 LinkedIn lek (6.5 miljoen niet-gezouten SHA-1s) perfect illustreert de kracht van de hybride. In 72 uur, de hashcat gemeenschap had gekraakt:

  • 100% wachtwoorden in top-10M wordlists (zuiver woordenboek)
  • 90% meer via best64 + Combineatoraanval
  • Resistente wachtwoorden: alleen die zonder woordenboekstructuur
  • Post-crack analyse onthulde dat "linkin1," "Linkedin1," "l!unked!n" en "LINKEDIN" alle varianten van "linkin" samen tienduizenden gecompromitteerde rekeningen vertegenwoordigden.


    3. Conceptuele stichtingen: Waarom de hybride werken

    3.1 Het menselijk gedrag van "veilig"

    Wanneer een systeem legt regels van complexiteit (majuscule, nummer, symbool), gebruikers niet willekeurig genereren . voorspelbare transformaties toepassen op memorizeerbare woorden :

    Menselijke strategieVoorbeeldBijbehorende hybride regel
    Eerste letter als hoofdletter"sunshine" → "Sunshine"c (capitalize first)
    Alles in hoofdletters"sunshine" → "SUNSHINE"u (uppercase all)
    Een cijfer aan het eind toevoegen"sunshine" → "sunshine1"$1 (append "1")
    Het jaartal toevoegen"sunshine" → "sunshine2024"$2 $0 $2 $4
    e→3 vervangen"sunshine" → "sunshin3"s e 3 (substitute e by 3)
    a→@ vervangen"password" → "p@ssword"s a @
    Het woord omkeren"sunshine" → "enihsnus"r (reverse)
    Het woord verdubbelen"sun" → "sunsun"d (duplicate)
    Een ! aan het eind toevoegen"sunshine" → "sunshine!"$!
    Meerdere combineren"password" → "P@ssw0rd1"c s a @ s o 0 $1

    Deze transformaties lijkt creatief aan de gebruiker. precies de eerste die de aanvaller probeert Zij komen overeen met de beperkingen die het veiligheidsbeleid oplegt.

    3.2 Het concept van efficiënte vermindering van de ruimte

    Een 10-karakter wachtwoord met letters+cijfers+symbolen heeft een ruwe sleutelruimte-kracht van 94^10, 5,4 × 10^19 combinaties. Te groot om in een redelijke tijd te reizen.

    Maar als dit wachtwoord "Password1!" is een triviale transformatie van "wachtwoord" is het onder de 500 eerste kandidaten De aanvaller reist niet 5.4 × 10^19 combinaties: hij reist 500.

    Dit is de fundamentele vermindering van de hybride aanval: de werkelijke ruimte van menselijke keuzes is astronomisch kleiner dan de theoretische ruimte van mogelijke karakters.

    3.3 De machtswet van transformatie

    Net zoals rauwe wachtwoorden een wet van macht (Zipf) volgen de transformaties die mensen toepassen ook een zeer geconcentreerde distributie. Ma et al. (2014) empirisch toonde:

  • ~5% van de transformaties ("toevoegen 1 aan het einde," "kapitaliseren de eerste letter") dekken ~50% van de reële gevallen
  • ~20% van de transformaties dekt 85% van de gevallen
  • De resterende 80% van de omzettingen betreft slechts 15% van de gevallen
  • Door deze concentratie kunnen 64 goed gekozen regels (best64) een dekking bereiken van 79-855%, waarbij 64 willekeurige regels slechts 10-15% zouden bereiken.

    3.4 Interactie met de populariteit van het basiswoord

    Hoe vaker het basiswoord, hoe eerder het afgeleide wachtwoord is in de lijst van de aanvaller prioriteit. De aanvaller beveelt zijn kandidaten in afnemende waarschijnlijkheid:

    Kandidaten die de aanvaller genereert (testvolgorde):
      password        (kaal woord, meest gangbaar)
      Password        (capitalize first)
      password1       ($1)
      PASSWORD        (uppercase all)
      password!       ($!)
      p@ssword        (substitute a→@)
      passw0rd        (substitute o→0)
      Password1       (c + $1)
      P@ssword        (c + s a @)
      password123     ($1 $2 $3)
      ...
      p@ssW0rd!       (complexe combinatie)

    "wachtwoord" is het meest voorkomende woord → zijn derivaten worden eerst getest. "papillon" is minder gebruikelijk → zijn derivaten worden veel later getest. Deze prioritering is het centrale mechanisme dat de drie verschillende sleutelruimtes in Time2Crack verklaart.


    4. Architectuur van een moderne hybride aanval

    4.1 Algemene pijpleiding

    Fase 1: Keuze van de wordlist
        ├── Gelekte wachtwoorden gesorteerd op frequentie (RockYou, HIBP, Collections)
        ├── Taalwoordenboeken (fr.txt, en.txt, de.txt...)
        ├── Thematische wordlists (voornamen, steden, merken, tv-series)
        └── Contextuele wordlists (doeldomein, namen van medewerkers, vaktermen)
    
    Fase 2: Keuze van de regelset
        ├── best64.rule (evenwichtige referentie, 64 regels)
        ├── OneRuleToRuleThemAll.rule (52.000 regels, met ML gegenereerd)
        ├── d3ad0ne.rule (34.000 regels, empirisch)
        ├── JtR-regels (generated.rule, specific.rule, extra.rule)
        └── Eigen regels (afgestemd op het doeldomein)
    
    Fase 3: Expansie (wordlist × regels)
        ├── Voor elk woord w in de wordlist:
        │     Voor elke regel r in de regelset:
        │       kandidaat = apply(r, w)
        │       Als kandidaat ≠ w en kandidaat nog niet getest:
        │         kandidatenwachtrij.push(kandidaat)
        └── Volgorde: (w1, regel1), (w1, regel2)... (w2, regel1)...
            of: (w1, regel1), (w2, regel1)... afhankelijk van de strategie
    
    Fase 4: Hashen en vergelijken (GPU)
        ├── Batches van ~10M kandidaten naar de GPU
        ├── Parallelle berekening van de hashes (SIMD, 219 GH/s voor MD5)
        ├── Vergelijking met de doelhash(es)
        └── Bij een match: GEVONDEN — log(kandidaat, hash, regel)
    
    Fase 5: Rapportage
        └── Gekraakte kandidaat + gebruikte regel + rang in de lijst

    4.2 Hashcat-methoden

    Hashcat implementeert de hybride op twee verschillende manieren:

    Modus -a 0 (woordenlijst + regels) Dit is de klassieke hybride modus.
    hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule
    Modus -a 6 (woordenlijst + masker) : combineert een woordenlijst met een positionaal masker. Genereert alle combinaties word + masked_suffix.
    hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
    # Tries "sunshine0000", "sunshine0001", ..., "sunshine9999"
    Modus -a 7 (masker + woordlijst) : Inverse, gemaskerd voorvoegsel + woord.
    hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
    # Tries "00sunshine", "01sunshine", ..., "99sunshine"

    Time2Crack modelleert vooral de modus -a 0 (overschrijvingsregels), die betrekking hebben op het overgrote deel van de daadwerkelijk gedocumenteerde hybride aanvallen.

    4.3 Orde van kandidaten en prioriteitenstrategie

    De volgorde waarin kandidaten worden getest is cruciaal.

    Strategie eerst (standaard hashcat): alle regels worden toegepast op W1 alvorens over te stappen op W2.
    (W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...
    Voordeel: als W1 zeer waarschijnlijk is (bijvoorbeeld "wachtwoord"), ontdekt u snel zijn varianten. Regel-eerste strategie : alle woordenlijsten worden uitgevoerd voor R1 voordat ze naar R2 gaan.
    (W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...
    Voordeel: de meest effectieve regel (: → mot brut) wordt eerst toegepast op alle woorden. Vaak effectiever voor diverse corpus.

    In de praktijk gebruikt hashcat standaard woord-eerste, maar ervaren operators kiezen volgens het doelprofiel.


    5. Stelt mutatieregels

    5.1 Syntaxis van hashcat-regels

    De hashcat-regels worden uitgedrukt in een minimumtaal waarin elk teken een operatie op de kandidaat-string vertegenwoordigt:

    Gevalmodifiers :
  • : Identiteit (bruto woord, geen transformatie)
  • l Alle kleine letters ("PASSWORD" → "wachtwoord")
  • u
  • c Kapitaliseren eerste, kleine geval rust ("PASSWORD" → "Wachtwoord")
  • C
  • t Inschakelen van alle tekens ("Wachtwoord" → "PASSWORD")
  • TN Schakel het vakje van teken naar positie N
  • Verwijderingen en omkeringen :
  • r Omkeren ("wachtwoord" → "drowssap")
  • d Dupliceren ("wachtwoord" → "wachtwoordwachtwoord")
  • f
  • { Roteer links ("wachtwoord" → "wachtwoordp")
  • } Rechts draaien ("wachtwoord" → "dpasswor")
  • [ Verwijder eerste teken ("wachtwoord" → "wachtwoord")
  • ] Het laatste teken verwijderen ("wachtwoord" → "passwor")
  • Tekenaanvullingen :
  • $X X toevoegen ("wachtwoord" + $1 → "wachtwoord1")
  • ^X Prepend teken X ("wachtwoord" + ^1 → "1wachtwoord")
  • iNX Plaats teken X op positie N
  • Instellingen :
  • sXY Vervang alle X door Y ("wachtwoord" + s a @ → "p@ssword")
  • SNX Vervang teken op positie N door X
  • Truncings :
  • 'N Afkappen op positie N (wachtwoord + '4 → "pass")
  • DN Teken verwijderen op positie N
  • Voorwaardelijk :
  • <N — Past de regel alleen toe als de lengte < N is
  • >N — Past de regel alleen toe als de lengte > N is
  • =N — Past de regel alleen toe als de lengte = N is
  • 5.2. Samengestelde regels

    Regels kunnen op één lijn worden geketend om complexe transformaties te creëren:

    c $1          → "Password1" (capitalize + append 1)
    c $! $1       → "Password!1" (capitalize + append ! + 1)
    s a @ s e 3   → "p@ssw3rd" (substitute a→@ and e→3)
    r $1          → "1drowssap" (reverse + append 1)
    u $2 $0 $2 $3 → "PASSWORD2023" (uppercase + append year)

    Macht zit in de samenstelling: 64 eenvoudige regels genereren duizenden verschillende transformaties door combinatie.

    5.3 Hoofdregels

    best64.rule (Löfstrand, 2013) OneRegleToRegleThemAll (NotSoSecure, 2019) d3ad0ne.rule 34.096 Communautaire regels, gericht op patronen die niet onder de beste64 vallen (accenten, uitgebreide karakters, niet-Engelse patronen). live.rule 99 000+ regels, de meest uitgebreide. Gebruikt voor lange termijn kraken wanneer anderen mislukt. Algemeen2.regel (JtR) Automatische gegenereerd door statistische analyse van reeds gekraakte wachtwoorden. Herberekend periodiek als nieuwe lekken optreden.

    6. Best64 regels: het referentiespel

    Best64 is de set van 64 standaard regels van referentie in academische literatuur en industrie. Hier zijn de belangrijkste regels en hun empirische rechtvaardiging:

    6.1 De 20 meest effectieve regels (in volgorde van uitvoering)

    RangRegelTransformatie% gedekte wachtwoorden (Ma 2014)
    1:Woord ongewijzigd~18%
    2cCapitalize first~11%
    3uUppercase all~6%
    4$1Append "1"~5%
    5lLowercase all~4%
    6$!Append "!"~3%
    7s a @a→@~2,8%
    8c $1Capitalize + "1"~2,5%
    9$2Append "2"~2,1%
    10rReverse~1,9%
    11$! + cCapitalize + "!"~1,7%
    12s o 0o→0~1,6%
    13dDuplicate~1,4%
    14s e 3e→3~1,3%
    15$1 $2 $3Append "123"~1,2%
    16c $1 $2 $3Capitalize + "123"~1,1%
    17$0Append "0"~1,0%
    18^1Prepend "1"~0,9%
    19s i 1i→1~0,8%
    20c $! $1Capitalize + "!1"~0,7%
    Cumulatieregels 1 : ~55% van op dict gebaseerde wachtwoorden Cumulatieregels 1 : ~68% van dict-gebaseerde wachtwoorden Cumulatieregels 1 : ~79% van op dict-gebaseerde wachtwoorden

    6.2 Waarom zijn deze regels zo doeltreffend?

    Elke top-10 regel komt overeen met een gemeenschappelijk veiligheidsbeleid:

  • "Shall have a capital capital" → gebruikers kapitaliseren de eerste letter (c)
  • "moet een nummer hebben" → gebruikers voegen "1" toe aan het einde ($1)
  • "Zal een symbool" → gebruikers toevoegen "!" ($!)
  • "moet letters EN cijfers hebben" → c $1 of c $1 $2 $3
  • Password beleid niet echt verhogen veiligheid als gebruikers te implementeren voorspelbare transformaties


    7. Volledige taxonomie van transformaties

    7.1 Categorie 1: Case transformaties

    Gebruik makend van de verplichting om kapitaal te hebben:

  • Hoofdletter: "zonneschijn" → "Zonneschijn" (meest voorkomende regel na het woord rauw)
  • Alle hoofdletters: "zonneschijn" → "zonneschijn"
  • Schakel afwisselend in: "zonneschijn" → "sUnShInE"
  • Laatste letter hoofdletter: "zonneschijn" → "zonneschijn"
  • CamelCase: "sunshinE" (bij benadering door c veranderingen)
  • Prevalentie : Klein (1990) merkt op dat 41% van "wachtwoorden met hoofdletters" simpelweg bestaat uit het woord met de eerste letter in hoofdletters.

    7.2 Categorie 2: Digitale achtervoegsels en voorvoegsels

    Gebruik maken van de verplichting om een cijfer te hebben:

  • Enkel cijfer toevoegen: woord+"0" aan woord+"9"
  • Voeg twee cijfers toe: woord+"00" aan woord+"99" (100 combinaties)
  • Einde jaar : woord+"1990" tot woord+"2024" (35 frequente combinaties)
  • Voeg "123" of "1234" toe (zeer vaak)
  • Eén cijfer vooraf: "1"+mot à "9"+mot
  • Prepend jaar: "2024"+word
  • Prevalentie Veras et al. (2014) vinden dat ~73% van de "verplichte" wachtwoorden het cijfer in achtervoegsel toevoegen. Slechts ~12% prefix het.

    7.3 Categorie 3: Leervervangers

    Systematische vervanging van letters door soortgelijke cijfers of symbolen:

    VervangingEmpirische frequentie
    a → @23% van de wachtwoorden met @
    e → 331% van de wachtwoorden met 3
    i → 119% van de wachtwoorden met 1
    o → 027% van de wachtwoorden met 0
    s → $14% van de wachtwoorden met $
    l → 18%
    t → 76%
    g → 94%

    Gecombineerde vervangingen ("P@ssw0rd") lijken complex maar worden gegenereerd in een paar regels: c s a @ s o 0Zij behoren tot de 500 eerste kandidaten Op wachtwoord.

    7.4 Categorie 4: Symbolische achtervoegsels

    Gebruik maken van de verplichting om een speciaal karakter te hebben:

  • Voeg "!" toe: het vaakst toegevoegde symbool (~35% van de symbolische toevoegingen)
  • "" toevoegen?: ~8%
  • "#" toevoegen: ~6%
  • Voeg "@" toe: ~5%
  • Voeg "." toe: ~4%
  • Voeg "!!" toe: ~3%
  • Prepends "!": minder frequent (~10% van de gevallen vs 35% voor suffix)
  • Kombinaison : woord + "1!" komt zo vaak voor dat het systematisch wordt gegenereerd door best64. "zonneschijn1!" behoort tot de eerste 200 kandidaten gegenereerd op "zonneschijn."

    7.5 Categorie 5: Structurele veranderingen

    Minder frequent maar nuttig voor sommige profielen:

  • Inversie: "zon" → "naakt" (huidig voor bepaalde groepen)
  • Duplicatie: "zon" → "zonzon" (wachtwoorden voor systemen beperken tot 8 tanks opgelost tot 16)
  • Rotatie: "wachtwoord" → "wachtwoordp"
  • Truncation + addition: "passw" + "1"
  • 7.6 Categorie 6: Compound transformaties (geavanceerd niveau)

    Complexe regels combineren verschillende bewerkingen:

    c $1 s a @        → "P@ssword1" (capitalize + append 1 + substitute a→@)
    u $! $1 $2 $3     → "SUNSHINE!123" (uppercase + append !123)
    r c $1            → "Drowssap1" (reverse + capitalize + append 1)
    s e 3 s a @ c $!  → "P@ssw3rd!" (multiple substitutions + capitalize + !)

    Deze transformaties lijken zeer complex, maar blijven aantoonbaar door een goede set van regels. OneRuleToRuleThemAlle bevat duizenden van deze.


    8. Frequentieprioriteit: Het hart van effectiviteit

    8.1. De frequentie van het basiswoord bepaalt de prioriteit

    Een intelligente aanvaller past de regels niet uniform toe op alle woorden.

  • Meest voorkomende woorden (boven-100 RockYou/HIBP) × alle regels
  • Woorden matig algemeen (top-10k) × meest effectieve regels
  • Minder frequente woorden (alle woordenboek) × eerste paar regels
  • Deze strategie wordt uitgevoerd in hashcat via het sorteren van de woordenlijst door het verlagen van de frequentie in combinatie met de woord-eerste strategie. Het verklaart waarom "Password1" (afgeleid van "wachtwoord," het woord #1) wordt gekraakt in milliseconden, terwijl "Soleil1" (afkomstig van "zon," woord ~5000 uit het Franse woordenboek) een paar seconden kan duren.

    8.2 Mediane positie in zoekruimte

    De belangrijkste maatregel is: het mediane aantal geteste kandidaten voordat het doelwachtwoord wordt gevonden. Ma et al. (2014) geven empirische metingen:

    CategorieVoorbeeldMediaan kandidaten tot succes
    TOP100"password1", "P@ssword"~450–500
    Gangbaar woordenboek (top-10k)"Sunshine1", "sunshine!"~5.000–15.000
    Minder gangbaar woordenboek"Papillon2024"~50.000–200.000
    Niet in een woordenboek"Xk7#mP9q"N.v.t. (hybride niet van toepassing)

    Deze metingen zijn de directe basis van Time2Crack constanten:

    const HYBRID_KEYSPACE_COMMON = 500;    // Ma et al. 2014 — median, top-100
    const HYBRID_KEYSPACE_DICT   = 8_000;  // Ma et al. 2014 — median, common dictionary
    const HYBRID_KEYSPACE_FULL   = 128e6;  // Gosney 2012 — best64 × 2M words, exhaustive

    8.3 Voorwaarden die nodig zijn om de hybride toe te passen

    Hybride aanval vereist het wachtwoord te zijn structureel afgeleid van een woordenboekwoordTime2Crack detecteert deze aandoening via hybridVuln :

    const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));
  • dictWord = true : het wachtwoord is of is afgeleid van een taalwoordenlijst
  • common && lettre : het wachtwoord verschijnt in GEMEENSCHAPPELIJK (HIBP top-400) en bevat letters
  • Als dictWord noch hybridVuln het wachtwoord bevat geen detecteerbare woordenboek root null Een puur willekeurig wachtwoord als "xK9#mQ7@" is niet kwetsbaar voor hybride.


    9. Uitvoering in Time2Crack: addHybridAttacks()

    9.1 Volledige geannoteerde code

    function addHybridAttacks(rows, hybridVuln, weak, common, dictWord) {
      if (hybridVuln || weak) {
        // Keyspace chosen from the popularity of the base word:
        // common → word in HIBP top-400 → position ~500 in the attacker's list
        // dictWord → word in the wordlist → position ~8000
        // otherwise (hybridVuln without dictWord or common) → exhaustive scan ~128M
        const hybridKS = common ? HYBRID_KEYSPACE_COMMON
          : dictWord ? HYBRID_KEYSPACE_DICT
          : HYBRID_KEYSPACE_FULL;
    
        for (const a of ALGOS) {
          rows.push({
            atk: t("aHybrid"),
            hash: a.name,
            rate: a.rate,
            // budgetTime: the keyspace IS the number of guesses — no division by 2
            // (unlike bruteTime, candidates here are ordered by probability)
            sec: weak ? weakGuessTime(a.rate) : budgetTime(hybridKS, a.rate),
            note: weak ? t("nWeakPassword") : t("nDictMut"),
            cat: "hybrid",
          });
        }
      } else {
        // Password with no dictionary structure → hybrid not applicable
        rows.push({
          atk: t("aHybrid"),
          hash: "(all)",
          rate: 0,
          sec: null,                     // N/A in the table
          note: t("nStructUnrecog"),
          cat: "hybrid",
        });
      }
    }

    9,2 budgetTime vs bruteTime

    Het onderscheid tussen beide functies is fundamenteel:

    // bruteTime: the attacker does not know where the password sits in the space.
    // On average they test half of it before finding it. → keyspace/2
    function bruteTime(keyspace, rate) {
      const ls = Math.log(keyspace / 2) - Math.log(rate);
      return Math.exp(ls);
    }
    
    // budgetTime: the attacker tests candidates in decreasing order of probability.
    // The keyspace IS the expected number of candidates before a hit (median position).
    // No division by 2 — the median is already built into the Ma 2014 constants.
    function budgetTime(guesses, rate) {
      const ls = Math.log(guesses) - Math.log(rate);
      return Math.exp(ls);
    }

    Voor de hybride, budgetTime is correct omdat de 500/8000/128M kandidaten empirische schattingen van de mediane positie, geen totale ruimte om te reizen.

    9.3 Relatie met isDictWord()

    Detectie dictWord welke voorwaarden de keuze van hybride sleutelruimte wordt geproduceerd door isDictWord() :

    function isDictWord(pw) {
      if (!DICT_WORDS || !DICT_WORDS.size) return false;
      const l = pw.normalize("NFC").toLowerCase();
    
      // Direct test: is the password in the dictionary as is?
      if (DICT_WORDS.has(l)) return true;
    
      // De-leeted test: "s0le1l" → "soleil" in the dictionary?
      const dl = deLeet(pw);
      if (dl !== l && DICT_WORDS.has(dl)) return true;
    
      // Substring test: does "sunshine123" contain "sunshine" from the dictionary?
      for (const w of DICT_WORDS) {
        if (l.includes(w) && w.length >= 4) return true;
      }
    
      return false;
    }

    Deze detectie bepaalt niet alleen of de hybride van toepassing is, maar ook welke sleutelruimte (vaak vs dict) wordt gebruikt om de tijd te berekenen.


    10. De drie hybride sleutelruimtes en hun rechtvaardiging

    10.1 HYBRID_KEYSPACE_COMMON = 500

    Achtergrond Het wachtwoord is in GEMEENSCHAPPELIJK de hardgecodeerde lijst HIPP top-~400. Dit zijn enkele van de meest voorkomende wachtwoorden in de wereld ("wachtwoord," "letmein," "sunshine," "iloveyou" ...). Rechtvaardiging Ma et al. (2014) empirisch gemeten dat de mediane positie van een top-1000 wachtwoord in een hybride lijst gesorteerd op waarschijnlijkheid ~450 kandidaten is. Het getal 500 is een enigszins conservatieve schatting om tot ~400 rang te dekken. Interpretatie : een aanvaller die best64 toepast op een woordenlijst gesorteerd op frequentietests gemiddeld 500 kandidaten voor het vinden van het wachtwoord. Bij 2600 GH/s (MD5, 12× RTX 5090), 500 kandidaten = 0,19 ns- Bijna onmiddellijk. Voorbeeld : "Sunshine1" → "sunshine" is in GEMEENSCHAPPELIJK → HYBRID_KEYSPACE_COMMON = 500 → budgetTime(500, 2634e9) 0,19 ns.

    10.2 HYBRID_KEYSPACE_DICT = 8.000

    Achtergrond Het wachtwoord is afgeleid van een woord uit de taalwoordenlijst, maar niet van GEMEENSCHAPPELIJK. Dit zijn gewone woordenschat woorden ("zon," "berg," "paillon"...) met transformaties. Rechtvaardiging Ma et al. (2014) meet een mediane positie van 2000 tot 15.000 afhankelijk van de populariteit van het woord in RockYou. De empirische mediaan is ~ 8000. Deze sleutelruimte weerspiegelt dat de aanvaller het woord en zijn varianten test na het vermoeien van de meer voorkomende kandidaten. Interpretatie : 8.000 kandidaten bij 2.600 GH/s (MD5) = 3,0 nsVoor bcrypt (114 kH/s): 8.000 / 114 000 0,07 seconden. Voorbeeld : "Soleil2024" → "zon" in fr.txt → HYBRID_KEYSPACE_DICT = 8000 → een paar nanoseconden op MD5, 0,07s op bcrypt.

    10.3 HYBRID_KEYSPACE_FULL = 128.000.000

    Achtergrond : hybridVuln is waar (wachtwoord heeft een woordenboekstructuur) maar geen van beide common noch dictWord De aanvaller moet door de hele wordlijst bladeren met alle regels. Rechtvaardiging : Gosney (Passwordscon 2012) documenteert een woordenlijst van 3,5M woorden × best64 (64 regels) = 224M kandidaten in totaal. In de praktijk maken realistische woordenlijsten 2M woorden en de gedeeltelijke beste64 runs stoppen bij ~128M kandidaten voordat klimmen naar bredere regels. Formule : 2_000_000 woorden × 64 regels = 128_000_000 kandidaten Interpretatie : 128 miljoen kandidaten bij 2600 GH/s (MD5) 49 µs. Op bcrypt (114 kH/s): ~19 minuten.

    11. Kalibratie van hoge trouw

    11.1 Rol van hoge betrouwbaarheid

    Wanneer de hoge betrouwbaarheidsmodus (HF) wordt geactiveerd in Time2Crack, wordt een extra multiplier toegepast op de berekende tijd om de nauwkeurigheid te verfijnen. Voor hybride aanval houdt deze multiplier rekening met factoren die niet worden vastgelegd door de basissleutelruimtes.

    HF multiplicators voor hybride

    In applyHighFidelityCalibration() :

    case "hybrid":
      // Very common words: cracked even earlier than the Ma 2014 median,
      // because modern attackers sort word-first and rule-first at the same time.
      // 30% reduction on times that are already short.
      m *= context.common ? 0.7
        : context.dictWord ? 0.8
        : 1.0;
      break;
    Rechtvaardiging :
  • Voor common : moderne gereedschappen (hashcat met --markov-thresholdDe beste kandidaten komen nog eerder aan.
  • Voor dictWord : minder effect omdat de positie in de woordenlijst minder geconcentreerd is.
  • Voor hybridVuln alleen (FULL keyspace): geen enkele vermindering van volledige sleutelruimte is al een conservatieve schatting.
  • 11.3 Interacties met de monotone bewaker

    De monotone bewaker zorgt ervoor dat geen gespecialiseerde aanval beweert te zijn sneller dat de ruwe kracht op de alfabetische subtekenreeks van het wachtwoord:

    // For each non-brute-force row:
    const floorAlpha = bruteTime(Math.pow(26, alphaOnly.length), algo.rate);
    if (row.sec < floorAlpha) row.sec = floorAlpha;

    Voor korte woorden (bv. "cat" = 3 letters, vloer = 26^3/rate


    12. Relatie met afgeleide aanvallen

    12.1 Hybrid vs. Puur woordenboek

    CriteriumPuur woordenboekHybride
    Geteste kandidatenExacte woorden uit de lijstWoorden + al hun varianten
    Dekking (RockYou)~18%~79-85% (met best64)
    Keyspace (200k woorden)200.000200.000 × 64 = 12,8M
    ToepasbaarheidWachtwoord = exact woordWachtwoord afgeleid van een woord
    Kwetsbaar voorbeeld"sunshine" (exact)"Sunshine1!", "sunsh1ne"
    Bestendig voorbeeld"Sunshine1""xK9#mQ7@" (geen stamwoord)

    12.2 Hybrid vs Regelgebaseerd

    De regelgebaseerde aanval in Time2Crack is conceptueel vergelijkbaar maar met een veel bredere set regels:

    const RULE_KEYSPACE = 250_000_000;  // vs 128M for full hybrid

    Het verschil: de beste64 model hybride (64 regels, focus op gemeenschappelijke menselijke transformaties). De regel gebaseerde aanval modellen bredere games zoals d3ad0ne (34k regels) of OneRuleToRuleThemAll (52k regels), gebruikt wanneer best64 faalt. De regel-gebaseerd is de "tweede lijn" hybride

    12.3 Hybrid vs. PCFG

    PCFG (Probabilistic Context-Free Grammar, Weir 2009) modelleert de grammaticale structuur van het wachtwoord om kandidaten te genereren.

    CriteriumHybridePCFG
    AanpakBasiswoord + transformatieregelsGlobale grammaticale structuur
    Sterk puntAangepaste bestaande woordenStructuren van het type "Woord+Cijfers"
    Voorbeeld"sunshine" → "Sunshine1"Herkent de structuur "Hoofd+klein+cijfer"
    AanvullingReageert op dictWordReageert op een herkende structuur
    Keyspace (Time2Crack)500 / 8k / 128MpcfgKeyspace(pw), dynamisch berekend

    PCFG kan aanvallen wachtwoorden zonder root woordenboek als hun structuur komt vaak voor (ex: "Thelonious8" → geen woord van de dico maar structuur Capitalize+lower+digit zeer voorspelbaar).

    12.4 Hybrid vs Morfologisch (morf)

    De morfologische aanval test taalkundige varianten (flexions, variaties). Het is een generalisatie van de hybride voor talen met rijke morfologie:

  • Hybride: "zon" → "Zon1," "s0leil," "zon!"
  • Morfologisch: "zon" → "zon," "zon," "zon," "zon," "zon"
  • De hybride werkt op het oppervlak van het woord (karakter transformaties), de morfologische werkt op de lexicale structuur (derivatie, buigen), en ze zijn complementair.


    13. Benchmarks per hash-algoritme

    13.1 Tijd voor de drie hybride sleutelruimtes (12× RTX 5090)

    AlgoritmeSnelheid (H/s)COMMON (500)DICT (8k)FULL (128M)
    MD52.634 GH/s0,19 ns3,0 ns49 μs
    SHA-1837 GH/s0,60 ns9,6 ns153 μs
    SHA-256332 GH/s1,5 ns24 ns386 μs
    NTLM4.081 GH/s0,12 ns2,0 ns31 μs
    bcrypt (kosten 10)114 kH/s4,4 ms0,07 s19 min
    Argon2id1.000 H/s0,5 s8 s36 uur
    Lezen : voor MD5 en NTLM wordt zelfs de FULL keyspace (128M-kandidaten) gekraakt in een paar dozijn microseconden. Argon2id is het enige algoritme dat sterk weerstand biedt, zelfs voor gewone woorden: 0,5 seconden voor een GEMEENSCHAPPELIJK woord, 8 seconden voor een dictwoord. Deze tijden blijven kort in absolute waarde, maar vertegenwoordigen een vertraging van x10^9 vs MD5

    13.2 Impact van het aanvalsprofiel

    Time2Crack biedt twee profielen (Ervaren 12 GPU, Professional 100 GPU). Voor de hybride, het profiel verschil is direct evenredig:

    ProfielGPU’sFactorFULL bcrypt
    Ervaren12× RTX 50901×19 min
    Professioneel~100 GPU~8×~2 min

    Voor MD5, SHA-1, NTLM: het profiel verandert de tijd van microseconden naar nanoseconden, zonder enige praktische impact, beide zijn onmiddellijk.


    14. Concrete voorbeelden van hybride kraken

    14.1 Voorbeeld 1: "Wachtwoord1" (COMMON)

    Analyse :
  • isCommon("Password1") → onwaar (niet in exact HIPP)
  • isDictWord("Password1") → waar ("wachtwoord" in DICTW VERMELDINGEN in kleine letters)
  • COMMON.has("password") → waar → common = true
  • Resultaat: HYBRID_KEYSPACE_COMMON = 500
  • MD5 tijd : 500 / 2,634e12 0,19 ns (snapshot) Tijd bcrypt kosten 10 500 / 114 000 4,4 milliseconden Regels getest vóór het vinden : : (bruto woord "wachtwoord" → nee), c ("Wachtwoord" → nee), c $1 ("Wachtwoord1" → FIND, rij ~8)

    14.2 Voorbeeld 2: "Sun2024" (DICT)

    Analyse :
  • isCommon("Soleil2024") → onwaar
  • isDictWord("Soleil2024") → waar ("zon" in fr.txt)
  • COMMON.has("soleil") → vals → common = false, dictWord = true
  • Resultaat: HYBRID_KEYSPACE_DICT = 8.000
  • MD5 tijd : 8 000 / 2,634e12 3,0 nanoseconden Tijd bcrypt kosten 10 : 8 000 / 114 000 0,07 seconden Testvoorschriften : de aanvaller arriveert op ~5000 in de woordenlijst fr gesorteerd op frequentie, dan geldt c $2 $0 $2 $4 ("Sun2024") in de rij ~3 van zijn regels → algemene positie ~15 003.

    14.3 Voorbeeld 3: "p@pillon!" (DICT met substituties)

    Analyse :
  • isDictWord("p@pillon!") : de-leetification → "paillon" → in fr.txt → dictWord = true
  • Resultaat: HYBRID_KEYSPACE_DICT = 8.000
  • Testvoorschriften : "paillon" at ~15.000 of the dictionary fr. Rule s a @ $! → "p@pillon!" in rij ~12. Algemene positie: ~180.000. Altijd goed in HYBRID_KEYSPACE_DICT.

    14.4 Voorbeeld 4: "xK9#mQ7@" (bestendig)

    Analyse :
  • isDictWord("xK9#mQ7@") → onwaar (geen root woordenboek)
  • isCommon("xK9#mQ7@") → onwaar
  • hybridVuln = false
  • Resultaat: sec = null → hybride niet van toepassing
  • Dit wachtwoord kan niet worden gekraakt door hybride aanval. Het heeft geen woordenboek root. De aanvaller moet gebruik maken van pure brute kracht, PCFG of statistische aanvallen (Markov, Neural).

    14.5 Voorbeeld 5: "LinkedInB3st!"

    Analyse :
  • isDictWord("LinkedInB3st!") : "linkin" → wordlist en.txt + deLeet("b3st") → "beste" → dictWord = true
  • Resultaat: HYBRID_KEYSPACE_DICT = 8.000
  • Interessant geval: het wachtwoord bevat twee roots ("linkedin" en "best" via de-leetification). Hybride aanval is van toepassing omdat ten minste één root wordt gedetecteerd. In de praktijk zou een combinatoraanval (twee woorden gelijmd) hier nog effectiever zijn.


    15. Hybride aanvalslimieten

    15.1 Intrinsieke grenswaarden

    Afhankelijk van de kwaliteit van de woordenlijst : als het basiswoord niet in de woordenlijst staat, kan de hybride niet werken. Een wachtwoord gebaseerd op een zeer gespecialiseerde term (neologisme, obscure technische term, woord van een zeldzame taal) kan weerstaan als het ontbreekt in alle gangbare woordenlijsten. Onvolledige dekking van transformaties : zelfs OneRuleToRuleThemAlle met 52k regels dekt niet 100% van de denkbare transformaties. Sommige zeer zeldzame transformaties (base64 gedeeltelijke coderingen, uitgevonden patronen) ontsnappen aan de regels. Combinerende explosie met lange Wordlists Bij 2.600 GH/s (MD5), duurt het ~ 190 seconden, maar met bcrypt (114 kH/s), ~ 140 jaar. De schaalbaarheid van de hybride wordt beperkt door de lengte van de wordlist en de traagheid van de hash algoritme.

    15.2 Wat Time2Crack niet vastlegt

    Context Woordenlijsten : een aanvaller die zich richt op een specifiek bedrijf zal een woordenlijst bouwen met de naam van het bedrijf, producten, namen van werknemers, zakelijke termen. "Renault2024!" zou direct worden gekraakt door een aanvaller gericht Renault Multipass-composietregels Sommige wachtwoorden weerstaan best64 maar geven toe aan twee-pass regels (toepassing van de ene regel, pas dan een andere regel toe op het resultaat). Time2Crack model slechts één regel pass. Cache effecten en geheugen : hashcat onderhoudt een tabel van kandidaten al getest om duplicaten te vermijden, die versnelt loopt in de praktijk. Niet gemodelleerd in Time2Crack (conservatief).

    15.3 Gevallen waarin de hybride wordt overschat

    Time2Crack kan hybride snelheid overschatten in twee gevallen:

  • Lange wachtwoorden Een 20-karakter wachtwoord op basis van een woord woordenboek ("onbegrijpelijkheden1!") wordt gedetecteerd als een woordenboek, maar hybride hulpmiddelen filteren meestal kandidaten te lang. De echte sleutelruimte is misschien 10× groter.
  • Talen met rijke morfologie Turks, Fins, Hongaars hebben meer complexe woordenlijsten. "Güneş2024" kan onder radars passeren als de Turkse woordenlijst niet alle morfologische vormen bevat.

  • 16. Doeltreffende verdediging

    16.1 Wat bestand is tegen hybridisatie

    Hybride aanval mislukt als het wachtwoord komt niet voort uit een bestaand woordenboekwoordEffectieve strategieën:

    Willekeurige wachtwoorden "xK9#mQ7@vP2!" bevat geen woordenboekwortel. Geen enkele hybride regel kan het genereren. Weerstand: maximum. Wachtwoordgenerators : wachtwoord managers (Bitwarden, 1Password, KeePass) genereren willekeurige strings. Geen root woordenboek → hybride niet van toepassing. Wachtwoorden van echt willekeurige woorden : "tabouret-marmot-ginger-flash" vier willekeurige woorden. Hybride aanval in de klassieke modus genereert geen combinaties van 4 woorden (dit is de rol van de combinator). Passphrase weerstaat de standaard hybride.

    16.2 Wat is GEEN resistentie tegen Hybride

    De meest voorkomende "versterkingsstrategieën" verzetten zich niet tegen:

    StrategieVoorbeeldWeerstand
    Eerste letter als hoofdletter"Sunshine"❌ Regel c, rang 2
    Een cijfer toevoegen"sunshine1"❌ Regel $1, rang 4
    Een symbool toevoegen"sunshine!"❌ Regel $!, rang 6
    e→3 vervangen"sunshin3"❌ Regel s e 3, top-20
    Alles combineren"Sunshin3!"❌ Samengestelde regel, top-100
    Een zeldzaam woord kiezen"papillon123"❌ Staat toch in wordlists
    Het woord verdubbelen"sunsun"❌ Regel d, top-30
    Omkeren"enihsnus"❌ Regel r, top-15
    Conclusie Elke strategie op basis van "neem een woord + wijzigen" is kwetsbaar voor de hybride. De uitzondering is zo'n complexe en zeldzame wijziging dat het niet wordt gedekt door een regel ..maar als de gebruiker moet onthouden deze complexe transformatie, hij eindigt meestal kiezen voor iets voorspelbaar.

    16.3. Resistent hash-algoritmen

    Zelfs als een wachtwoord kwetsbaar is voor de structurele hybride, kan het hash-algoritme de aanval economisch onlevenbaar maken:

    AlgoritmeTijd voor DICT (8k pogingen)Aanval in de praktijk
    MD5 / NTLM~3 nanosecondenDirect
    SHA-256~24 nanosecondenDirect
    bcrypt kosten 10~0,07 secondenTriviaal
    bcrypt kosten 14~1 secondeHaalbaar
    Argon2id (standaard)~8 secondenHaalbaar
    Argon2id (sterke parameters)~100 secondenTraag maar mogelijk
    Argon2id met hoge parameters (t=4, m=65536) is het enige algoritme dat de hybride echt duur maakt, zelfs op zwakke wachtwoorden.

    16.4 Praktische aanbevelingen

  • Wachtwoordbeheer gebruiken : genereert zuivere willekeurige, niet van toepassing hybride
  • Indien nodig : 4+ woorden eigenlijk willekeurige wachtwoordzin (uit EVF)
  • Nooit "veilig" een woord door vervanging : de hybride genereert ze automatisch
  • Vereiste bcryptkosten ≥ 12 of Argon2id serverzijde: de enige echte langzamer
  • MVO inschakelen : maakt offline kraken theoretisch zonder operationele impact

  • 17. Referenties

    Academische publicaties

    Klein (1990) "Foiling the Cracker": Een overzicht van, en verbeteringen aan, wachtwoordbeveiliging Werkzaamheden van de USNIX Security Workshop, 1990. Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009) Wachtwoord volgen met behulp van probabilistische contextvrije grammatica's IEEE Symposium on Security and Privacy (S&P), 2009. Opgericht het PCFG model en geldig door de manier waarop de hashcat regels betrekking hebben op 78% van de menselijke transformaties waargenomen in RockYou. Ma, J., Yang, W., Luo, M., & Li, N. (2014) Een studie van Probabilistische Password Modellen IEE Symposium on Security and Privacy (S&P), 2014. Wat? Directe referentiestudie voor Time2Crack: empirische meting van mediane posities (500 voor top-100, 2000 Durmuth, M., Chaabane, A., Perito, D., & Castelluccia, C. (2015) Wanneer Privacyvergaderingen Beveiliging: Persoonlijke gegevens voor Wachtwoord volgen ESORICS 2015. Veras, R., Collins, C., & Thorpe, J. (2014) Op de Semantische patronen van wachtwoorden en hun impact op de beveiliging NDSS 2014. Taalanalyse van semantische patronen. Ur, B., Bees, J., Segreti, S. M., Bauer, L., Christin, N., & Cranor, L. F. (2015) Komen gebruikerspercepties van wachtwoordbeveiliging overeen met realiteit? ACM CHI 2015. Demonstreert dat gebruikers systematisch de sterkte van gemuteerde wachtwoorden overschatten. "P@ssw0rd" ontvangt een subjectieve score van "sterk" maar wordt gekraakt in < 1s. Wheeler, D.L. (2016) zxcvbn: Low-Budget Wachtwoord Sterkteschatting 25e USENIX Security Symposium, 2016. Krachtschatting bibliotheek integratie mutatie regel detectie. Referentie voor de implementatie van detectie heuristiek.

    Industriële conferenties en presentaties

    Gosney, J (2012)
    8x Nvidia GTX 580 Cluster Hashcat Benchmarks / LinkedIn crack sessie Wachtwoordencon 2012, Oslo. Documenteer de LinkedIn crack: best64 + wordlist 3.5M = 224M kandidaten, 90% gebarsten in 6 dagen. Basis voor HYBRID_KEYSPACE_FULL = 128M. Löfstrand, K. (2013) best64.rule Intern, gepubliceerd op GitHub. Een set van 64 regels die empirisch geselecteerd zijn op RockYou om de cracksnelheid te maximaliseren. Steube, J. (2016 Hashcat Advanced Password Herstel https://hashcat.net/hashcat/ Officiële mode documentatie -a 0, -a 6, -a 7. Syntaxis van regels. Officiële GPU benchmarks op 12× RTX 5090. NotSoSecure (2019) OneRegleToRegleThemAll https://github.com/NotSoSecure/password_cracking_rules 52 218 regels gegenereerd door automatisch leren op corpus van gebarsten wachtwoorden.

    Referentiegereedschappen

    John de Ripper (Solar Designer, 1996 https://www.openwall.com/john/ Pioneer van de wordlist+rules hybride. JtR syntax altijd gebruikt parallel met Hashcat. Hashcat (Steube, 2009 https://hashcat.net/hashcat/ Referentie GPU implementatie. Modi -a 0/6/7 voor hybride. best64 geïntegreerd. RockYou wordlist (2009) 14,3M duidelijke wachtwoorden. Standaard kalibratie corpora voor alle hybride regelsets. Seclists (Daniel Miessler, 2012 https://github.com/danielmeissler/SecLists Collectie van wordlists per taal, domein, thema. Belangrijkste bron van Time2Crack taal wordlists.

    Webbronnen geciteerd in de Time2Crack-toepassing

    Chick3nman (Hashcat benchmarks/regels). https://gist.github.com/Chick3nman/32e662a5bb63bc4f51b847bb4222fd Verwante bron descHybrid (app.js) voor de orde van grootte van de toegepaste mutatieregels. IEEE Xplore (hybride referentie). https://ieeexplore.ieee.org/document/6956583 Verwante bron descHybrid (app.js) betreffende de empirische effectiviteit van gemuteerde wachtwoorden.
    Document gegenereerd als onderdeel van het Time2Crack-project 2026 Zie ook: BRUTEFORCEAANVAARDINGUITGEBREIDE MD, MARKOVAANVAARDINGTOELICHTINGAANVAARDINGUITGEBRACHT.md