ყველაფერი 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

6 Responses to “ყველაფერი MD5-ის შესახებ”


  1. 1 D@niko დეკემბერი 9, 2009, 19:58

    რაღაცეებს მივხვდი, მაგრამ მთლად ბოლომდე ვერა :D

  2. 4 CONTROLLER მაისი 16, 2016, 15:18

    md5-ს ვერ გაშიფრავ მაგრამ მაქვს ასეთი შეკითხვა,თუ ნებისმიერი რაოდენობის სიმბოლოების შეყვანისას იღებ უნიკალურ ანუ განსხვავებულ ყოველთვის 32 სიმბოლოიან კომბინაციას,მაგალითად 1000000000000000იანი ასოსგან შემდგარ ტექსტის დაახლოებით 10000000000000 ვარიანტს ყველას განსხვავებული შიფრი როგორ ექნება და თან ყველას 32 სიმბოლო? დავასკვენი რომ ეს შეუძლებელია და მივედი იმ საბოლოო დასკვნამდე რომ თუ ვინდოუსზე დააყენებ პაროლს იგი შეიძლება გატყდეს სხვა პაროლით რომელსაც ექნება იგივე დაშიფრული 32 სიმბოლოიანი კომბინაცია და ამ პაროლის რომლის გარტყმის შანსი ალბათ 0.0000000000000000000000001%-ზე ნაკლები იქნება.ესეიგი პირველ პოსტთან წიღნააღმდეგობაში მოვედი :/ ვინც მიხვდა რა დავწერე საღოლ :D

    • 5 Dixtosa ივლისი 6, 2016, 18:34

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

    • 6 Sulkhan Dzirkvadze მარტი 26, 2017, 21:28

      MD5 ალგორითმი თექვსმეტობით სისტემას იყენებს და შესაბამისად ძალიან ბევრი ვერსიის მიღება შეიძლება. 1_სა და 32 (10000000000000000000000000000000) ნულისგან მიღებული რიცხვი ზღვარი არ არის :)

      შესაბამისად, კოლიზიის დაშვების აუცილებობა არ არსებოს :)


კომენტარის დატოვება

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / შეცვლა )

Twitter picture

You are commenting using your Twitter account. Log Out / შეცვლა )

Facebook photo

You are commenting using your Facebook account. Log Out / შეცვლა )

Google+ photo

You are commenting using your Google+ account. Log Out / შეცვლა )

Connecting to %s




სტატისტიკა:

  • 25,496 hits

free counters

აბირჟავებენ


%d bloggers like this: