Archive for the 'Cracking' Category

ყველაფერი MD5-ის შესახებ

კრიპტოგრაფიაში (MD5 Message-Digest algorithm 5) არის ხშირად გამოყენებადი, ლოგიკური ოპერატორებისგან აწყობილი რთული, 128 ბიტიანი ჰეშ დაშიფრვაა.

წინასწარ მოდით შევთანხმდეთ ტერმინებზე:
`ჰეში/hash` დავარქვათ ენკოდირებულ მონაცემს.
`პასვორდი` სიყტვას(მონაცემს) რომელიც გვინდა რომ დაიკრიპტოს.
`ვორდლისტი` ვუწოდოთ იმ სიას სადაც სავარაუდო პასვორდებია ჩაწერილი.

ჰეში ხშირად გამოისახება 32 HEX რიცხვებით(0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f). მაგ.:

A კონვერტირტება ასე: 7fc56270e7a70fa81a5935b72eacbe29
Gio კონვერტირდება ასე: f4e1d215f2df0639c0bdbd37bb54c68d
Dixtosa კონვერტირდება ასე: 2eaef0637ebc9cd83057b5123f75590f

Online Crypters
http://md5.gromweb.com/
http://www.iwebtool.com/md5
http://md5-hash-online.waraxe.us/

Online DeCrypters
http://www.md5decrypter.co.uk/
http://milw0rm.com/cracker/insert.php

დეკრიპტი მხოლოდ შეიძლება ორი გზით:
1)Rainbow Table
2)BruteForce

არცერთი ამ ორთაგან ვერ გაშიფრავს ერთი კლიკით ერთ წამში,ვინაიდან და რადგანაც მდ5 გაუშიფრავია დღესდღეისობით.

პირველი ხერხი იყენებს მონაცემთა ბაზას სადაც უკვე დაკრიპტული ჰეშებია. მარა ადვილი მისახვედრია მათი ზომები საოცრად დიდია.(GB-დან TB-მდე), მიუხედვად ამისა ის უფრო სწრაფი საშუალებაა პასვორდის დასაკრეკათ.

მეორე ხერხი ბრუტერია ანუ (პროგა/სკრიპტი) დაიწყებს ვორდლისტის თითოეულ ხაზზე მყოფ პასვორდის დაკრიპტვას და რომელიც დასაკრეკი ჰეშის იდენტური იქნება იმაზე გაჩერდება და გამოიტანს შედეგს.

MD5 გამოიყენება ისევე როგორც ინტერნეტში განსაკუთრებით ფორუმებზე, ასევე (ფასიან) პროგრამებზე.

როგორც ამბობენ MD5 არის Collision resistance, რაც ნიშნავს იმას, რომ ორი(ან მეტი) განსხვავებული პასვორდი, ვერ მიიგებს ერთიდაიგივე ჰეში.

Ronald Linn Rivest (დაიბადა 1947, Schenectady, ნიუ ორკი)–<<კაცი რომელმაც ეს ალგორითმი შექმნა უფრო სწორედ გაანახლა MD4-დან 1991წელს.
სხვათაშორის მდ5-ის აგმოაჩნდა(ადრეულ ხანებში) რაგაც ნაკლი და მანამ ბოლომდე დაუძლურდებოდა ეს ალგორითმი კრიპტოგრაფერებმა რეკომენდაცია მისცეს რომ გამოეყენებინა სხვა ალგორითმები როგორიცაა SHA-1.

ეს ალგორითმი, შეუქცევადობის გამო გამოიყენება ესე ხშირად და მასიურად.

სალტიანი ჰეშ
ზოგიერთ ფორუმებზე(და არა მარტო) ასევე გამოიყენება ორმაგი დაკრიპტვა.

იმისთვის რომ წარმოიდგინოთ რას ნინნავს სალტიანი ჰეშ, მივიჩნიოთ რომ ეს ფუნქცია: md5(“a”)-აბრუნებს a-ს md5 ჰეშს(ამ შემთხვევაში ეს ტოლია:0cc175b9c0f1b6a831c399e269772661-ის.).

სალტიანი ჰეშ გენერირდება ასე:
md5(md5(SaltCode)+md5(password))
სადაც:
SaltCode არის რაღაც კოდი რომელსაც სერვერი რეგისტრაციის(მაგალითად ფორუმზე) დროს შემთხვევით აიგებს და ინახავს ბაზაში. ეს შეიძლება იყოს რაგაც ასეთი: Li6#Ga
password არის ის პაროლი რომელსაც მომხმარებელი რეგისტრაციის დროს წერს.

+ ნისაჰნავს მიმატებას ანუ გამოდის რომ md5(SaltCode)+md5(password) არის 64 სიმბოლოიანი.
ანუ ბოლოს 64 სიმბოლოიან პასვორდის დაკრიპტავს და შეინახავს ბაზაში.

ლოგინ-ის დროს ხდება ასეთი რამ: სერვერი გამოიძახებს იმ კოდს(SaltCode) რომელიც მითითებულ მომხმარებელზეა მინიჭებული, დაკრიპტავს მას და მითითებულ პასვორდს მიამაგრებს ამ ორ ჰეშს ერთმანნეთთან, ამ შედეგსაც დაკრიპტავს და თუ ბაზაში არსებულ ჰეშს დაემთხვა მაშინ მომხმარებელი წარმატებით შევა ფორუმში. აღსანიშნავია ის ფაქტი რომ Rainbow table salt-თან უძლურია.

უსალტო ფორუმზე განსხვავებით სალტიანისგან შეიდზლება მომხმარებლის პაროლის შეცვლა, რატომ? იმიტომ რომ არავინ არ იცის(‘დაჟე’ არც ადმინმა) რომელ იუზერს რომელი SaltCode შეესაბამება, ‘იცის’  მხოლოდ ფორუმმა. ხშირად ადმინებს ეშლებათ ხოლმე ეს და უაზროდ უცვლიან იუზერს პაროლს …

აქვე გთავაზობთ python script-ს, რომელიც კრიპტავს პასვორდს. :)

import sys,math,structS=[[7,12,17,22],
[5,9,14,20],
[4,11,16,23],
[6,10,15,21]]

O=[0,1,5,0]
M=[1,5,3,7]

T = map(lambda i: long(4294967296.0*abs(math.sin(i))), range(1,65))

A,B,C,D=struct.unpack(“<IIII”,”\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10″)

F = lambda x,y,z: x&y | (~x)&z
G = lambda x,y,z: x&z | y&(~z)
H = lambda x,y,z: x^y^z
I = lambda x,y,z: y^(x|(~z))

def K(f,a,b,c,d,xk,s,i):
a += f(b,c,d)+xk+T[i]
a &= (2**32-1)
a = (a << s) | (a >> (32-s))
return (a+b) & (2**32-1)

FF = lambda *args: K(F,*args)
GG = lambda *args: K(G,*args)
HH = lambda *args: K(H,*args)
II = lambda *args: K(I,*args)

Func=[FF,GG,HH,II]

finished=0
l=0
while 1==1:

if finished:
chunk = chunk[64:]
if len(chunk) < 64:
break
else:
chunk = raw_input(“PassWord”)
l += len(chunk)
if len(chunk) < 64:
# Padding is always added :
# \x80+some \x00+bitlen (on 8 bytes, little endian)
# so that the input length is a multiple of 64 bytes.
chunk += “\x80”
chunk += “\x00″*( (64+56-(l+1))%64 )
chunk += struct.pack(“<II”,(l*8)&(2**32-1),((l*8)>>32)&(2**32-1))
finished = 1

L=[A,B,C,D]
for round in range(4):
for j in range(4):
for k in range(4):
ofs= ((j*4+k)*M[round]+O[round]) % 16
L[-k]=Func[round](L[-k],L[1-k],L[2-k],L[3-k],
struct.unpack(“<I”,chunk[4*ofs:4*ofs+4])[0],
S[round][k], round*16+j*4+k)
A+=L[0]
B+=L[1]
C+=L[2]
D+=L[3]

def pr(x):
return “%02x%02x%02x%02x” % (x&0xff, (x>>8)&0xff, (x>>16)&0xff,(x>>24)&0xff)

print pr(A)+pr(B)+pr(C)+pr(D)

Advertisements

სტატისტიკა:

  • 30,068 hits

free counters

აბირჟავებენ

Advertisements