Posts Tagged 'პითონი'

First Steps With Python_Mutable & immutable objects

ზოგიერთი ობიექტი პითონში მაგალითად string-ები tuple-ები და number-ები არიან immutable(უცვლელნი), მათი შეცვლა ფუნქციაში/მეთოდში შექმნის ახალ ცვლადს და ფუნქციის გარეთ ცვლადები ხელუხლებელი დარჩება, ხოლო list-ისა და dictionary-ს შეცვლა არ შექმნის ახალ ცვლადს და შესაბამისად ცვლილება აისახება ფუნქციის გარეთ. ასეთ ტიპებს mutable(ცვალებადი) ობიექტები ჰქვიათ.

ლუქ ეთ ზის:
list=[123,456,789]
dic={"123":"abc","456":"def","789":"ghi"}
def change(a,b):
        a.remove(123)
        b.pop(“123”)

change(list,dic)
print list
print dic

Continue reading ‘First Steps With Python_Mutable & immutable objects’

Advertisements

რატომ პითონი?

  1. სინტაქსს საშუალო დონეზე ძალიან მალე ისწავლი. საუბარია საათობრივ თანრიგზე და არა დღეზე, კვირაზე ან თვეზე.
  2. pdb მოდულით თავისუფლად შეგიძლია გააჩერო პროცესი სადაც გინდა. დებაგერია.
  3. აქვს ძალიან გამოსადეგი მოდულები.
  4. მოჰყვება ოფლაინ დოკუმენტაცია (ინტერნეტი აღარაა პრობლემა მაგრამ მაინც:) ) ცალკე მოდულად, სადაც ყველა მოდული კარგადაა ახსნილი.
    import pydoc
    pydoc.gui()
  5. ობიექტზე ორიენტირებული პროგრამირება მარტივია.
  6. პითონი არის მკაცრი ენა. ერთი რაღაცა ყველაზე მარტივად შეიგძლია გააკეთო მხოლოდ ერთი გზით,დანარჩენი თუ იქნა ე.ი. რთული გზაა.
  7. IPython არის ძალიან კარგი REPL(ანუ იგივე კონსოლი)
  8. თუ გინდა რომ დაათვალიერო კლასი, მოდული ან საერთოდაც ნებისმიერი ტიპის ობიექტი იყენებ დაჩდგმულ ფუნქციას: dir. ვთქვათ გვაქ ობიექტი X მასზე ინფორმაციას მოვიპოვებთ ასე: dir(x). რაც ჩემი აზრით დამწყებისთვის ძალიან მნიშვნელოვანია სწრაფად ასათვისებლად. ეს ფუნქცია კი სასიცოცხლო მნიშვნელობისაა ტურისტებისთვის , ანუ მათთვის ვინც არჩევს პითონს კოდს და შეიძლება არ იყოს ენის სწავლით დაინტერესებული, მაგრამ მოდი ვიყოთ რეალურები და ვთქვათ სიმართლე: მავანი რომკბილს მოუსინჯავს პითონს ვეღარ შეელევა მერე მას :)).
  9. აქვს შესანიშნავი გარე მოდულები (sympy,skype4py,numpy), უბრალოდ გაოცდები.
  10. py2exe საშუალებას იძლევა კოდი გაშვებადი გახადო, კომპზე სადაც პითონი არაა დაყენებული. ამას აკეთებს ინტერპრეტატორის და ბიბლიოთეკების მიბმით დაკომპილირებულ კოდთან ერთად. ცოტა ჩალიჩის მერე ერთი exe ფაილიც შეგიძლია მიიღო.
  11. Jpython JVM-სი ხოლო IronPython CLR (.NET) იმპლემენტაციებია.
  12. თითქმის ყველაფერი არის ძალიან კარგად დოკუმენტირებული.
  13. აქვს OpenGL მხარდაჭერა (PyOpenGL)
  14. GUI Toolkit-ის ფარტო ასორტიმენტი.
  15. ლინუქსის ზოგიერთ დისტროს (უბუნთუს მაგალითად) მოჰყვება დაყენებული უკვე.
  16. import this

First Steps With Python_ოპერატორები

ოპერატორები

ოპერატორები არის ის რითაც შეგვიძლია ცვლადებზე მანიპულირება.

ოპერანდები კი ისინი რაზეც ოპერაციას ვასრულებთ.

არითმეტიკული ოპერატორები რიცხვებზე.

ოპერატორი განმარტება
x + y მიმატება
x - y გამოკლება
x * y გამრავლება
x / y გაყოფა *
x // y მთელი განაყოფი**
x ** y ხარისხში აყვანა (xy)
x % y ნაშთი***

*მთელი გაყოფა ანუ x და y ის განაყოფს ჩამოსცილდება წერტილის შემდეგი ციფრები(თუ ექნება რათქმაუნდა),ადამიანურ ენაზე:რამდენჯერ მოთავსდება y–ი x -ში.

**თუმცა 7/4–იც 1–ია და არა 1.75.ეს ხდება მაშინ როცა მთელ რიცხვს ჰყოფთ მთელ რიცხვზე. სხვა შემთხვევაში(მთელი ათწილადზე) 1.75,ამიტომ ყურადღებით.ეს შეიცვალა პითონ 3.x-ში.

***ანუ აბრუნებს ნაშთს. მაგალითად 13%4 არის 1.

მინიჭების ოპერატორები:

ოპერატორი განმარტება
x = y x-ს მიენიჭება y
x += y x-ს მიემატება y
x -= y x-ს გამოაკლდება y
x *= y x–ი გამრავლდება y–ზე
x /= y x–ი გაიყოფა y–ზე
x //= y x და y–ის მთელი განაყოფი მიენიჭება x-სს
x **= y x ახარისხდება y–ით
x %= y x % y–ეს მიენიჭება x-სს

შემდეგი ცხრილი არის ორობითი ლოგიკური ოპერატორები რომლებიც int და long int ებზე სრულდება მხოლოდ.

ოპერატორი განმარტება
x << y მარცხნივ გადაადგილება*
x >> y მარჯვნივ გადაადგილება*
x & y ორობითი AND**
x | y ორობითი OR**
x ^ y ორობითი XOR (eXclusive OR)**
~x ორობითი უარყოფა***

*ეს არის ორობითი ოპერაცია ესეიგი ოპერანდები ჯერ გადაიყვანება ორობითში და შემდეგ სრულდება ოპერაცია. ოპერაცია << გულისხმობს ორობითი რიცხვის გადააადგილებას მარცხნივ, მაგალითად:

x=1 #ორობითში 0001

y=2

x<<y იქნება 0100 (1 გადაადგილდა ორი ნაბიჯით).

ასევე არის მარჯვნივ გადაადგილებაზეც:

x=15 # ორობითში 1111

y=1

x>>y იქნება 111 (გადაადგილდა მარჯვნივ, რის შედეგად ჩამოეჭრა 1).

**დაწერილი მაქ აქ

*** ორობითი რიცხვების ინვერსია ანუ 1გადავა 0ში და პირიქით.

შემდეგი ცხრილში არის წარმოდგენილი შდარებითი ოპერატორები. რომლებიც აბრუნებენ boolean მნიშვნელობებს ანუ ან True-ს ან False-ს.

ოპერატორი განმარტება
x < y x ნაკლებია y-ზე
x > y x მეტია y–ზე
x == y ტოლია
x != y არ არის ტოლი
x >= y მეტია ან ტოლია
x <= y ნაკლებია ან ტოლია

ცხრილის მიხედვით, თუ x არ არის ნაკლები(ტოლია ან მეტია) y–ზე დააბრუნებს False–ს წინააღმდეგ შემთხვევაში True. ესაა ყველა სტქრიქონში აზრი, მაგალითად კიდე თუ x==y დააბრუნებს True-ს მოლოდ მაშინ თუ ეს რიცხვები ერთმანეთს უდრის.

შედარებები შეიძლება გაერთიანდეს კიდევაც ასე: w<x<y<z. ეს შედარებები შეგიძლია წარმოვიდგინოთ ასე: (w<x) and (x<y) and (y<z).

ასევე შეიძლება ასეც  x<y>z , მაგრამ მკითხველისთვის(გაითვალისწინე რომ მკითხველი შეიძლება შენც იყო!) ძალიან რთული წასაკითხია.

შენიშვნა:ბოლო შედარებაში, x-სა და z–ს შორის არაფერი შედარება არ ხორციელდება.

ოპერაციები რიცხვებზე მხოლოდ შეიძლება ერთიდაიგიე ტიპზე, მაგრამ თუ სხვადასხვა ტიპებს ადარებ, პითონი მოქმედებს ასე:

  1. თუ ერთერთი ოპერანდი არის კომპლექსური რიცხვი მეორეც/დანარჩენებიც გადავაიყვანება კომპლექსურზე.
  2. თუ ერთერთი ოპერანდი არის float მეორეც/დანარჩენებიც გადავაიყვანება float–ზე.
  3. თუ ერთერთი ოპერანდი არი long integer მეორეც/დანარჩენებიც გადაიყვანება long integer–ზე.

შენიშვნა:როცა ვმუშაობთ int რიცხვებზე და როცა რაღაც ბრძანების გამო რიცხვი იზრდება იქამდე რომ გადააჭარბა მაქსიმალურ ზღვარს(), ამ დროს პითონი ავტომატურად გადაიყვანს long integer–ში.

First Steps With Python_ცვლადები

მანამ ცვლადებზე გადავალთ, კომენტარები. პითონი კომენტარებს აღიქვამს # ამ სიმბოლოს შემდომ სიმბოლოებს ახალ ხაზამდე!

მაგრამ კომენტარის გაკეთება ეშმაკურადაც: სამ ბრჭყალებში(""" CommentText """) მოთავსებული ტექსტი საერთოდ არის DocString–ი(კლასებზე დაფუნქციებზე რომ გადავალთ დავაზუსტებ),რომელიც ამ ეტაპზე შეგვიძლია გამოვიყენოთ როგორც კომენტარი…

ცვლადების მინიჭება უმარტივესია,პითონში მისი ზოგადი სახე ასეთია:
variable_name=value
სადაც variable_name ცვლადის სახელია, ხოლო value მნიშვნელობა. ხოლო “=” ეს სიმბოლო არის მინიჭების სიმბოლო.

variable_name უნდა დაიწყოს ალფაბიტით ან ქვედატირეთი(underscore) ანუ a-Z ან _
variable_name ვერ იქნება ვერცერთი keyword. ხოლო keyword–ებია:
False,class,finally,is,return,None,continue,for
lambda,try,True,def,from,while,and,del,global
not,with,as,elif,if,or,yield,assert,else,import,in
pass,break,except,raise

კივორდების “საქმიანობებს” განვიხილავ მერე :)

მონაცემთა ტიპები:
არსებობს 6 ძირითადი ტიპი პითონში, ესენია:
1)integer–მთელი რიცხვი
2)long integer–დიდი დიაპაზონის მთელი რიცხვი
3)float–მცურავწერტილიანი რიცხვი,ანუ ათწილადი.
4)string–ტექსტი
5)list–სია,მონაცემებთა ერთობლიობა, რომელთა ინდექსირება ხდება რიცხვებით.
6)dictionary–სია,მონაცემებთა ერთობლიობა, რომელთა ინდექსირება ხდება ნებისმიერი string–ით.

მონაცემების მინიჭება ცვლადებზე(შესაბამისობა დაცულია):
1)My_INT=5
2)My_L_INT=-123L
3)My_FLOAT=-23.8
4)My_STRING="chemi teqsti :D ormagi brchyalit"
ასევე შესაძლებელია ასე:
4*)My_STRING_='chemi teqsti :D apostrofit'
4**)My_STRING__="""chemi teqsti :D sami brchyalit
romelsac sheudzlia axal xazzec wakitxva :))"""

^ამ შემთხვევაში ეს სამი ბრჭყალები Doc String-ად არ ჩაითვლება. ამ სამ ბრჭყალს აქ ის გამოყენება აქ რომ აღარ ხდება საჭირო ახალი ხაზის(‘\n’) სიმბოლოს გამოყენება.^
5)My_LIST=["dabaduba",26987,-9L,"""xazi#1
xazi#2""",0.003,[":)",'(:']]

–როგორც ხედავთ სია უნდა იყოს კვადრატულ ფრჩხილებში. ასევე შესაძლებელია სიაში იყოს სია.
6)My_DICT={"magida":"table","skami":"chair","dzagli":"dog"}
–როგორც ხედავთ dictionary ფიგურალურ ფრჩხილებშია მოთავსებული ინდექსი და ველი(ანუ სიის წევრი) ‘:’ ამით არის გამოყოფილი.
შენიშვნა ჩვენ შეგვიძლია ასეთი რამ:
a=b=c=d=5. მთავარია 5–ი იყოს ბოლოში. და ასეთი რამაც:
a,b,c,d=5,5,5,5.მთავარია 5იყოს იმდენჯერ რამდეჯერაც ცვლადებია მძიმით გამოყოფილი.

Python Trick: სხვა ენებში როცა გვინდა ცვლადებს(ვთქვათ a,b–ს) მნიშვნელობები გავცვალოთ ვაკეთებთ ასე:
droebiti_cvladi=a
a=b
b=droebiti_cvladi

მაგრამ პითონი გვაძლევს საშუალებას მარტივად გამოვიყენოთ მისი სინტაქსის ეს ნაწილი(გავიხსენოთ a,b,c,d=5,5,5,5)
a,b=b,a
[Python RuleZ :))]

მონაცემების მიღება(შესაბამისობა დაცულია,ანუ ზედა ექსვსიდან პირვლი პირველს ემთხვევა):
1)print My_INT-არაფერი განსაკუთრებული დაბეჭდავს ხუთიანს.
2)print My_L_INT-არაფერი განსაკუთრებული, დაბეჭდავს -123-ს და L-საც,ანუ:-123L.
3)print My_FLOAT-არაფერი განსაკუთრებული, დაბეჭდავს -23.8-ს
4)print My_STRING-არაფერი განსაკუთრებული, დაბეჭდავს “chemi teqsti :D ormagi brchyalit” (ბრჭყლაების გარეშე).
შენიშვნა: სთრინგის სიმბოლოზე წვდომა შეიძლება კუთხოვანი ფრჩხილით,რომელთა შორის იქნება რიცხვი, რომელიც გვეუბნება თუ მერამდენეა,ის. ანუ:
print My_STRING[0]–დაბეჭდავს:c–ს. იმიტომ რომ ის რიცხვი კი არ გვიჩვენებს მერამდენეა, არამედ თუ რამდენი სიმბოლოს შემდეგია სიმბოლო. ანუ:
print My_STRING[10]–დაბეჭდავს t-ს. ანუ სხვანაირად რო ვთქვათ პითონი ათვლას იწყებს 0–დან.
5)print My_LIST[0] აქაც იგივე პირველი წევრის გამოძახებისთვის კვ. ფრჩხილებში–0,მეორესთვის–1, დაასე შემდეგ. ანუ
My_LIST[0] არის: dabaduba
My_LIST[1] არის: 26987 და
My_LIST[3] არის:
xazi#1
xazi#2
6) აქაც სიის მსგავსად კვ. ფრჩხილები, და ახლა რიცხვის მაგიერ სთრინგი, რომელიც :–ის მარცნივ დგას. ანუ My_DICT–დან თუ გვინდა მაგიდის თარგმანი
(ამ კონკრეტულ შემთხვევაში ამ სიას ლექსიკონის დანიშნულება მივეცი,თან სიმბოლურია, სიის ტიპი ხომ dictionary–ა:)) ვწერთ ასე:My_DICT["magida"]. ფუნქცია დააბრუნებს: table–ს.
თუ დავწერთ My_DICT["skami"] იქნება chair. ალბათ გასაგებია ხომ?

PROBLEMS(შეამოწმე შენი თავი:)))
1)რომელია სწორი ფორმა?
a. _GiO_DiX="""" Gio Dixtosa :D"""
b. cvladi#1=12L
c. cvladiN-1=-89
d. False=-9L
პასუხი:a

რომელია არასწორი ფორმა?

a. VaRiaBle="True"

b. sityva="stringua :D'

c. RETURN= "-<?"

d. true,false="martalia",-1

პასუხი:b

First Steps With Python_Hello World

პითონზე მე უკვე შეგიქმენით წარმოდგენა წინა ამ პოსტში.

ახლა დავიწყოთ სწავლა…

პირველ რიგში რითიც ყველა იწყებს არის ბძანება კონსოლში ‘hello world’–ის გამოტანის :). პითონში ეს ასე ხდება :
print "hello world"
აქ ბრჭყალები შეიძლება იყყოს ორმაგიც(“) ან უბრალოდ აპოსტროფიც(‘).

ასე მარტივადაა ყველაფერი. ეს ბრძანება შეგვიძლია ორნაირად გავუშვათ:
1)ვაკეთებთ ახალ ფაილს .py გაფართოებით ვწერთ მოცემულ კოდს ვინახავთ და ფაილს ორჯერ ვაკლიკებთ. რადგან პითონი ინტერპრეტატორული ენაა ეგრევე გახსნის და გაუშვებს.
2)ვხსნით run-ს და ვწერთ შიგნით python-ს , იმიტომ რომ გაიხსნას პითონის კონსოლი,გახსნილ კონსოლშიც ვწერთ იგივე კოდს და Enter

მეორე შემთხვევაში ყველაფერს დავინახავთ და გაგვიხარდება(:დ) მაგრამ პირველ შემთხვევაში გაშვებისას დავინახავთ კონსოლს, რომელიც მალევე დაიხურება ეს იმიტომ რომ ჰელლო ვორლდის გამოტანის შემდეგ პროგას საქმე აღარ ‘დარჩა’,ასეთ დროს პროგა იხურება…
გავაკეთოთ ისე რომ პროგა მაშინ დაიხუროს როცა ჩვენ გვინდა, ამიტომ ვამატებთ
raw_input(“press Enter to close”). სინამდვილეში ეს არის ინფუთის(შეტანის ფუნქცია),შეგყავს სიმბოლოები აწვები ენთერს და პროგა ცვლადს ანიჭებს მიღებულ ინფორმაციას და დაიხურება. დეტალურად განვიხილავ მომდენო პოსტში.

ანუ გამოდის ასე:
print "hello world"
raw_input("press Enter to close")

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


სტატისტიკა:

  • 26,748 hits

free counters

აბირჟავებენ