Brute force hash attacker

  • Onderwerp starter Onderwerp starter bn2vs
  • Startdatum Startdatum
Status
Niet open voor verdere reacties.
Hoe ga jij alle mogelijkheden af?
Zou ik je code eens kunnen zien, ben heel nieuwschierig hoe jij het hebt gedaan :)


Geen idee hoe je een app voor een multicore maakt, zal het eens uitzoeken als ik tijd heb :D
 
ik bedoelde de code die je in die textfile had gezet :p

deze: http://code.tiko-world.com/forum/viewtopic.php?mode=attach&id=88


Me.gbxStats.Controls.Add(Me.lblTimeRemaining)
Me.gbxStats.Controls.Add(Me.Label9)
Me.gbxStats.Controls.Add(Me.lblTimeElapsed)
(...)
Me.gbxStats.Controls.Add(Me.pBarAttackStatus)
(...)
Me.gbxStats.TabIndex = 13
Me.gbxStats.TabStop = False
Me.gbxStats.Text = "Attack statistics"

:thumb:
 
Ja, dat is designer code hoor ;)

staat ook immers in
#region "Desinger"
 
Code:
Function compute(ByVal cstring As String(), ByVal max As Integer, ByVal needed As String, Optional ByVal prefix As String = "") As Boolean
        For Each Value In cstring
            If Not cancel = True Then
                newvalue = prefix & Value
                i += 1

                'Form1.lblCurrent.Text = newvalue
                hash = New Dynstr.DynStr(newvalue).ToMD5Hash()
                hashstr = hash.Text
                hash.Clear()
                If hashstr = needed.ToUpper Then
                    MsgBox(newvalue)
                    cancel = True
                    Exit For
                End If
                If (Not newvalue.Length = max) And (Not Value = Nothing) Then
                    compute(cstring, max, needed, newvalue)
                End If
                If i Mod 501 = 0 Then
                    Form1.lblDone.Text = i
                    Windows.Forms.Application.DoEvents()
                End If
                'If i2 = cstring.Length - 1 And Not currentlength = max Then
                'currentlength += 1
                'endif
            End If
        Next
        Return True
    End Function

De functie wordt aangeroepen met "compute('array met tekens',maximum lengte,gezochte hash)
Het vierde is voor de functie zelf.
Hij doet wel eerst a dan aa daarna aaa en zo verder, maar zo geraak je er ook. Het is een begin hé. DynStr class is dezelfde als jij gebruikte
 
Hey,

Ik heb ook wel ff moeten zitten op die functie toen ik hem maakte :)
Eigenlijk is het makkelijkste als je de text die je afloopt als een talstelsel beschouwt, zo kan je heel makkelijk alles aflopen.

Dat doe ik met deze code
currentPw = MathConverter.SharedFromDecimal(CULng(currentLvlPwNr), Me.CharacterSet, pwLen)

Als je wil stuur ik je die class door, heb hem nergens publiek staan. ;)

Wat doe je hier eigenlijk?
If i Mod 501 = 0 Then
Form1.lblDone.Text = i
Windows.Forms.Application.DoEvents()
End If

Is dat zodat je app niet zou vasthangen ofzo? En waarom 501?

Nice code anyway :thumb:
 
Wat doe je hier eigenlijk?
If i Mod 501 = 0 Then
Form1.lblDone.Text = i
Windows.Forms.Application.DoEvents()
End If
Is dat zodat je app niet zou vasthangen ofzo? En waarom 501?
Idd om niet vast te hangen, ik gebruik geen backgroundworker. 501 om in de form ook de eenheden te schrijven, anders telt hij per 500 (of ander rond getal)

Ruben
 
Een bgw is wss dus iets efficiënter :)

Ik ben op zoek naar manieren om mn prog te optimaliseren, de 1.0.3 versie doet iets over een miljoen mogelijkheden per minuut, maar het moet sneller kunnen. Een manier om aanvallen te kunnen verspreiden over meerdere sessies zou ook wel leuk zijn.

Iemand een idee hoe ik een van die dingen kan bereiken?

Alvast bedankt :)
 
Meerdere backgroundworkers, en er voor zorgen dat de ene de eerste helft van de pwds probeert en de andere de tweede helft. Lijkt me niet simpel...
 
Als ik selecteer:
- Lowercase latin [a-z]
- Upper case latin [A-Z]
- Digits [0-9}

Dan heb je 26+26+10 = 62 characterd... Toch geeft het progje aan "59" passwords to check (bij min en max length = 1)

Als ik nu ook nog "Special symbols" selecteer, blijft ie op 59 staan...

- om de een of andere reden voegen de digits 0-9 maar 7 mogelijkhedenen toe... niet logisch
- Als ik alles deselecteer: komt de debugger met een of ander bericht....
- Bij special symbols staan: áíúóùìòäïüö niet bij, terwijl die vaker voor zullen komen dan het kwadraat teken.

Verder mooi programma.. doet er precies 1.000.000 per minuut... hopelijk kan dat nog wat sneller op m'n dual core laptopje...

Jeffrey
 
- om de een of andere reden voegen de digits 0-9 maar 7 mogelijkheden toe... niet logisch
- Als ik alles deselecteer: komt de debugger met een of ander bericht....

> Inderdaad, maar die bugs waren al gevonden (staat in deze topic) :)

- Bij special symbols staan: áíúóùìòäïüö niet bij, terwijl die vaker voor zullen komen dan het kwadraat teken.
> Got a point there :thumb:

Ik ben nog steeds op zoek naar manieren om hem sneller te laten gaan. Desondanks dat ik een hele hoop bugs heb gefixed gaat de laatste versie toch merkbaar trager dan de eerste :(

Bedankt voor de feedback btw :)
 
Heb nieuwe versie gereleased :)

Check de eerste post in deze topic voor details :cool:
 
- *&"?ë staan nog niet in de rij van speciale symbolen
- Als je enkele charsets selecteerd en max length op 40 zet, komen de getallen zelfs achter has formaat te staan: misschien kun je hier 4.19E40 van maken oid... zodat het kort blijvt
- Misschien kun je punten toevoegen na 3 getallen.. dus 1.000.000.000 (overzichtelijker)
- De hele fun van de restart button snap ik niet.. wie wil er nu een hash gaan kraken en elke keer opnieuw beginnen???
- Het zou leuk zijn als er een save functie inzit.. als ik een pass van 8 tekens wil kraken ga ik dat niet in één dag doen, dus moet er opgeslagen worden waar hij exact gebleven is... (kan in register bijvoorbeeld)
- Passwords checked: punten toevoegen en getallen groter dan 9.99 miljard aangeven met en 9.99 E 9 (waar hij exact is boeit toch niet)
- Passwords remaining: exact zelfde als passwords checked.
- Time remaining: misschien kun je hier AA days XX:YY:ZZ in plaats van 56 miljoen uur, 9 min en 3 seconde :| OF alleen AA days indien groter dan 1 dag, en deze eens in de X 30 min updaten, en indien minder dan een dag in uren, min en sec weergeven en eens in 30 sec updaten.

Succes!
Jeffrey
 
Uitstekende suggesties :thumb:

Vooral een save functie zou idd heel handig zijn.

Een functie waarmee je bv abc*m*e*rty, waarin * de onbekende characters voorstellen zou ook leuk zijn, maar ik zie niet direct hoe ik dat zou kunnen implementeren zonder de performance daarvan naar de zak te helpen... Iemand een suggestie?
 
dit bestaat toch al half?

"he[$var]maal" met de MD5 "fb8af634d76ae006029ec2fa9f7b0992" zal resulteren in "helemaal"

hetzelfde princiepe moet je dan toepassen... Waarschijnlijk is het dan slim om de user in te laten geven hoeveel chars z'n [$var] mag hebben... door b.v. [1], [2], [3] te gebruiken, waarbij 1, 2 en 3 staat voor het maximum aantal tekens dat daar kan komen te staan...

"h[1]l[2]maa[3]" zal dus maximaal 11 tekens lang worden, waarbij er maar naar 6 tekens lang gezocht hoeft te worden...
De vraag is dan, begin je met "hlmaaX" of met "hXlXmaaX" waarbij de X vervangen wordt door het eerste teken waar naar gezocht wordt?

Ik denk dat het eerste de beste keuze is... en is nog makkelijk op te lossen ook, door een "leeg" "" (wat tussen de " staat) toe te voegen aan de zoeklijst....

ANDERS is het gewoon een kwestie van van rechts naar links werken...
waarbij je dus eerst:
hXlXmaaX -> hXlXmaaXX -> hXlXmaaXXX -> hXlXXmaaX -> hXlXXmaaXX -> hXlXXmaaXXX
Ook wel:
[1, 1, 1] -> [1, 1, 2] -> [1, 1, 3] -> [1, 2, 1] -> [1, 2, 2] -> [1, 2, 3]
Je zet dan in een geheugen hoeveel er op een bepaalde plek mag komen te staan, en als dat er staat, tel je 1 op bij een vorige plek....

Het voordeel van een leeg character toevoegen is dat je al die dingen niet hoeft te onthouden, maar gewoon zecht: [1] + [2] + [3] = 6 chars lang.
Ik ga alle chars langs van 6 chars lang, waarbij ik voor elk begin met een leeg char. Je onthoudt op welke plek welke char staat, plaatst deze in de zoekstring, maakt er md5 van, checkt en volgende....
Als je de _ even aanziet als leeg char:

_ __ ___ ==> hlmaa
_ __ __a ==> hlmaaa
e _e __l ==> helemaal => gevonden!


Succes :P
Jeffrey

p.s. ik hoop dat je er iets van begrijpt...
p.s.s. Door een leeg char toe te voegen, check je enkele malen exact dezelfde string..
a _a __a = a _a _a_ = a _a a__ = a a_ __a = a a_ _a_ = a a_ a__ ( = 2x3 plaatsen, is 6 overeenkomsten X aantal chars = veel)
Ik denk dat je dit kunt oplossen, door een regel aan te maken binnen een groepje:
[4] is een groepje van 4 chars... b.v "1234"
Als op plaats 2 een ander char staat, dan een leeg char, dan mag plaats 3 EN plaats 4 GEEN leeg char zijn....
Als je dan 2 groepjes hebt: [3] [3] b.v. "123 456"
Als op plaats 2 een ander char staat, dan een leeg char, dan mag op plaats 3 geen leeg char staan, maar op plaats 4, 5, 6 WEL, maar indien OOK 4 een ander char is dan leeg, dan mag op plaats 5 en plaats 6 OOK geen leeg char staan... conclussie: 2 groepjes zijn niet van elkaar afhankelijk!!!
p.s.s.s Dit gaat een boel scriptwerk opleveren... denkwerk staat hiet al boven, dus zal niet te moeilijk zijn :D succe!!!
 
Laatst bewerkt:
Hey, het bestaat inderdaat al half, maar er zit een reuzeverschil in de complexiteit van hoe het huidige replace ding werkt, en hetgeen jij voorsteld. Momenteel vertraagt die replace het aanvallen ongeveer 3x, en vermoed dat als ik hetgeen jij voorsteld ga doen het kan oplopen tot meer dan 10x :(

Vanuit gewoon user standpunt zou het echter wel een heel leuke functie zijn, en ik denk dat je zelf nog iets verder kan gaan.
a[2]ec[1-3]p => [2] betekend 2 chars, en [1-3] betekend 1 tot 3 chars

Wat vast staat is dat als ik dit als functie toevoeg het via een apparte procedure ga laten lopen :)

Als de onbekende char groepen lengtes constant zijn of er maar 1 variabele groep is kan ik het huidige systeem gebruiken, maar moet ik de gegenereerde paswoorden gewoon splitten en verdelen over de onbekende stukken. Als er echter meerdere variabele groepen zijn moet ik dus nog een loop toevoegen die de mogelijkheden afgaat als een lijst met elk maar 1 variabele groep, en dan het bovenstaande doet.

Wat de volgorde dan betreft van welke variabele groepen er eerst komen, zoals jij ook aanhaalde, weet ik nog niet echt. Zal ik wel zien als ik de code schrijf wat er het snelste gaat werken.

Als iemand nog een goed idee heeft om dit te realiseren, let me know :)
 
inderdaad, een eigen functie zul je er waarschijnlijk wel voor moeten maken :P

Ik denk dat je eens moet beginnen te proberen of een lege char aan de lijst toegevoegd kan worden.. als dat kan, zal het een boel werk schelen :P

Ik dacht... leuke uitdaging.. dus heb hem zelf ook ff'tjes gemaakt... koste me net iets meer dan 2:30 uur.. maar het was weer leuk :P

Ik zal hem vanmiddag ook ff op m'n server zetten, dan kun je het testen als je wilt...
Source zit erbij, werkt 100%!!! er kunnen oneindig veel "groepen" ([1-5]) ingevoegd worden, letters ertussen, [5], [10] is ook mogelijk en uiteraard kun je ook gewoon GEEN letters toevoegen, waardoor het zal werken als een gewone md5 cracker :P

Gezien een Apache server niet echt gemaakt is voor dit soort berekeningen, ben ik bang dat ik er weinig aan zal hebben :P leuk wat het wel.. dus tja :D

Ik wacht met spanning af op jouw script! (alhouwel ik hem zelf ook in VS08 / Autoit zou kunnen maken... maar daar heb ik geen zin meer in :D)

Zeer veel succes!
Jeffrey

p.s. ik moet nog eens naar je source gaan kijken :P misschien kan ik er wat leuks tussenvinden:thumb:


------------Edit-----------
http://www.24design.nl/md5/md5.php Het werkt :D
 

Bijlagen

Laatst bewerkt:
Nice code :thumb:

[x] word in jouw prog als [0-x] gezien, ik zou die eerder als gewoon x chars nemen, [0-x] kan je al ingeven he :)

Ik snap niet echt goed waar die 'lege char' voor dient :confused: Zou je dat ff kunnen verduidelijken?

Cheers,
BN
 
Las eerst je bericht hierboven verkeert :P
[x] wordt inderdaad als [0-x] gezien... en zoals je zecht "x chars" ervoor nemen (dus [x-x]) is inderdaad slimmer!
[x-y] is inderdaad ook in te geven :P


PHP:
  // "3" of "6" opgegeven (geheel getal)
    // $length slaat op:
    // [0] = Wat binnen de vierkante haken staat: b.v. 0-4 / 4 / 2-2
    // [1] = Minimaal aantal chars
    // [2] = Maximaal aantal chars
    $length[$nr][0] = substr($open[0][$nr], 1, (strlen($open[0][$nr])-2));
    $length[$nr][1] = 0; <-- REGEL 71
    $length[$nr][2] = $places;
    $totallength += $places; // optellen
    // Geen rekening houden met minimum aantal chars, omdat deze NIET opgegeven is...
    for($z=0; $z < $places; $z++)
    {
      $SaveArray[] = 0;
    }
Regel 71 (zie hierboven) moet dan even vervangen worden voor:
PHP:
    $length[$nr][1] = $places; <-- REGEL 71

Verder ook aanpassen:
    // WEL rekening houden met minimum aantal chars...
    for($z=0; $z < $places; $z++)
    {
      $SaveArray[] = 1;
    }

^^




"Lege char" In het volgende voorbeeld geeft "0" een leege plek in de array aan. Om aan te geven op welke plek WEL een waarde aanwezig is.

Input: "1[2]2[2-3]3"
Hiervoor reserveer je 2 + 3 plaatsen in het geheugen (in mijn geval via een array).
2+3 = 5 dus loop je alle mogelijke waarden af van "000000" tot "zzzzz"
Dan krijg je dus: "10020003" tot "1zz2zzz3"

Als je alleen de 26 letters van het alfabet gebruikt om alle mogelijkhedenen af te lopen (dus geen "leeg char") dan zou je op een gegeven moment de volgende overgangen krijgen.
0000z -> 000aa (correct)
000zz -> 00aaa (correct)
00zzz -> 0aaaa (incorrect!) dit moet zijn: 0a000
0zzzz -> aaaaa (incorrect!) die moet zijn: aa000


In het begin zal het goed gaan, omdat je in één groep bezig bent... Bij de 3e en 4e overgang ben je in 2 groepen bezig. Als je in de 2e groep een stap verder bent, dan zou je in de eerste groep weer helemaal overnieuw moeten beginnen, want in dit gevan niet gebeurt. Als je aan de 26 letters van het alfabet een lege char toevoegt, krijg je de volgende overgangen (lege char plaats je VOOR "a"). Lege char wil dus zeggen: de array is op die plek gevult met "niets". Ik geef hem weer met een "0".

0000z -> 000a0 (dubbel) Zelfde als "0000a"
000zz -> 00a00 (dubbel) Zelfde als "0000a" en "000a0"
00zzz -> 0a000 (Correct)
0zzzz -> a0000 (dubbel) Zelfde als "0a000"

Nu neem je wel alle mogelijkhedenen mee in je script MAAR heb je last van veel dezelfde code... Als je van een groep de code achter elkaar zet, maakt het niets uit of je "0a" of "a0" krijgt, bijde zal resulteren in "a". Zo ook "aa0", "a0a", "0aa" is allemaal "aa" als je ze aan elkaar plakt.

Om dit er dus ook uit te filteren, voeg je een regel toe:
Hierbij neem ik de groep "[2-3]" die 3 plaatsen heeft met de volgende namen: "3 2 1".

If positie( X ) != "leeg" AND positie( X-1 ) = "leeg" than positie( X-1) = "a" endif
dus als "3" = a, en "2" = "0" --> "2" = "a"

Je krijgt dan:
0000z -> 000aa (Correct)
000zz -> 00aaa (Correct)
00zzz -> 0a000 (Bijna Correct)
0zzzz -> aa000 (Bijna Correct)

Nu is er nog één ding waar je rekening mee moet houden:
Er is aangegeven [2-3] Dus minimaal aantal chars moet 2 zijn.
dus ook daar nog een IFje voor toevoegen

Code:
if(isset($SaveArray[$i]) AND $i >= (($length[$nr][2]+$start) - $length[$nr][1]) AND $SaveArray[$i] == 0)
{
  // Als er een minimum waarde is geset, ervoor zorgen dat die ook daadwerkelijk meegenomen wordt!
  $SaveArray[ $i ] = 1;
}


Je krijgt dan:
0000z -> 000aa (Correct)
000zz -> 00aaa (Correct)
00zzz -> 0a0aa (Correct)
0zzzz -> aa0aa (Correct)



Wat ik gedaan heb in mijn script, is niet de letter van het alfabet opslaan in de array, maar de positie van de letter in de string.
Zo werk ik dus de hele tijd met getallen in de array, wat een stuk makkelijker is dan werken met letters die opgeslagen worden :P
Pas als er gecontroleerd gaat worden, wordt de char, behorende bij het opgeslagen getal opgestuurd om te checken.

Alvast heel veel succes!
Jeffrey
 
Laatst bewerkt:
Status
Niet open voor verdere reacties.
Terug
Bovenaan Onderaan