დაშიფვრა PHP-ში. მონაცემთა დაშიფვრა, გაშიფვრა PHP დაშიფვრის და ავთენტიფიკაციის გასაღებების გასაღების გამოყენებით

თარგმანი
სახელმძღვანელო

მთარგმნელისგან: პროგრამირების პროცესში არასდროს მავიწყდება, რომ კრიპტოგრაფიაში სახიფათოდ არაკომპეტენტური ვარ და ყველას ვურჩევ, ამ თეზისიდან განაგრძონ (კარგი, იქნებ შენ და იმ მაგარი ბიჭის გარდა). თუმცა, ასეა თუ ისე, მუშაობის პროცესში წარმოიქმნება პრობლემები, რომლებიც დაკავშირებულია მონაცემთა დაცვასთან და ისინი უნდა მოგვარდეს. ამიტომ, თქვენს ყურადღებას ვაქცევ ფინელი დეველოპერის Timo H-ის სტატიის თარგმანს, რომელიც საკმაოდ საინტერესო და სასარგებლო აღმოჩნდა.

ეს არის სწრაფი გზამკვლევი იმის შესახებ, თუ როგორ ავიცილოთ თავიდან საერთო ხარვეზები PHP-ში სიმეტრიული დაშიფვრით.

ჩვენ განვიხილავთ შემთხვევას, როდესაც მონაცემები მუშავდება სერვერის მხარეს (კერძოდ, სერვერზე ხდება დაშიფვრა და მონაცემების მიღება შესაძლებელია, მაგალითად, კლიენტისგან სუფთა ტექსტის, პაროლის და ა.შ.) რაც ტიპიური შემთხვევაა PHP აპლიკაციებისთვის.

ამ სახელმძღვანელოში მოცემული ინფორმაცია არ უნდა იქნას გამოყენებული დაშიფრული ქსელური კავშირების შესაქმნელად, რომლებსაც აქვთ უფრო რთული მოთხოვნები. ასეთი შემთხვევებისთვის საჭიროა გამოიყენოთ spied ან TLS.

ბუნებრივია, აქ მოცემული რეკომენდაციები არ არის PHP-ში დაშიფვრის ორგანიზების „ერთადერთი შესაძლო გზა“. ამ სახელმძღვანელოს მიზანია შეეცადოს ნაკლები ადგილი დატოვოს შეცდომებზე და რთულ, ორაზროვან გადაწყვეტილებებზე.

დაშიფვრის ფუნქციები PHP-ში

გამოიყენეთ Mcrypt ან OpenSSL გაფართოებები.

დაშიფვრის ალგორითმი და მისი მუშაობის რეჟიმი, ერთჯერადი კოდი (ინიციალიზაციის ვექტორი)

გამოიყენეთ AES-256 CTR რეჟიმში შემთხვევითი ერთჯერადი კოდით ( დაახლ. თარგმანი: nonce). AES არის სტანდარტი, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი გაფართოების ფუნქციები - Mcrypt ან OpenSSL.

ყოველთვის შექმენით ახალი ერთჯერადი კოდი. ამ შემთხვევაში, თქვენ უნდა გამოიყენოთ შემთხვევითი რიცხვების კრიპტოგრაფიულად უსაფრთხო წყარო. წაიკითხეთ ცოტა მეტი შემთხვევითი რიცხვების წარმოქმნის შესახებ ქვემოთ. ერთჯერადი კოდი არ არის საიდუმლო და შეიძლება იყოს შერწყმული შიფრულ ტექსტთან გადასაცემად და შემდგომ გაშიფვრისთვის.

ერთჯერადი კოდი უნდა იყოს 128 ბიტი (16 ბაიტი) სიგრძის, მხოლოდ ბაიტის სტრიქონი ყოველგვარი კოდირების გარეშე.

Mcrypt გაფართოებაში AES ცნობილია როგორც Rijndael-128 ( დაახლ. თარგმანი: მიუხედავად იმისა, რომ ჩვენ ვსაუბრობთ AES-256-ზე, ეს არ არის შეცდომა. AES-256 != Rijndael-256). OpenSSL-ში, შესაბამისად, AES-256-CTR.

Mcrypt გამოყენების მაგალითი:
OpenSSL მაგალითი:
შეამოწმეთ, რომ დაშიფვრა მუშაობს სწორად ტესტის ვექტორების გამოყენებით ( დაახლ. თარგმანი: AES-256-CTR-სთვის იხილეთ პუნქტი F.5.5 57 გვერდზე).

CTR რეჟიმისთვის, არსებობს გარკვეული შეზღუდვები დაშიფრული მონაცემების მთლიან მოცულობაზე. ეს შეიძლება პრაქტიკაში არ შეგხვდეთ, მაგრამ გახსოვდეთ, რომ ერთი გასაღებით არ უნდა დაშიფროთ 2^64 ბაიტზე მეტი მონაცემი, მიუხედავად იმისა, არის ეს ერთი გრძელი შეტყობინება თუ ბევრი მოკლე.

CTR რეჟიმი სტაბილური რჩება მხოლოდ იმ შემთხვევაში, თუ არ იყენებთ ერთჯერად კოდს იმავე კლავიშით. ამ მიზეზით, მნიშვნელოვანია ერთჯერადი კოდების გენერირება შემთხვევითობის კრიპტოგრაფიულად ძლიერი წყაროს გამოყენებით. გარდა ამისა, ეს ნიშნავს, რომ არ უნდა დაშიფროთ 2^64-ზე მეტი შეტყობინება ერთი გასაღებით. ვინაიდან ერთჯერადი კოდის სიგრძეა 128 ბიტი, შეტყობინებების (და მათი შესაბამისი ერთჯერადი კოდების) რაოდენობის ლიმიტი 2^128/2 მნიშვნელოვანია დაბადების დღის პარადოქსის გამო ( დაახლ. თარგმანი:).

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

მონაცემთა ავთენტიფიკაცია

ყოველთვის შეამოწმეთ მონაცემების ავთენტურობა და მთლიანობა.
ამისათვის გამოიყენეთ MAC დაშიფვრის შემდეგ. იმათ. ჯერ მონაცემები დაშიფრულია, შემდეგ კი HMAC-SHA-256 აღებულია მიღებული შიფრული ტექსტიდან, თავად შიფრული ტექსტისა და ერთჯერადი კოდის ჩათვლით.

გაშიფვრისას, ჯერ შეამოწმეთ HMAC შედარების ალგორითმის გამოყენებით, რომელიც მდგრადია დროის შეტევების მიმართ. პირდაპირ არ შეადაროთ $user_submitted_mac და $calculated_mac == ან === შედარების ოპერატორების გამოყენებით. კიდევ უკეთესია გამოიყენოთ "HMAC double check".

თუ HMAC შემოწმება წარმატებულია, გაშიფვრა შეიძლება უსაფრთხოდ განხორციელდეს. თუ HMAC არ არის შესაფერისი, დაუყოვნებლივ გამორთეთ.

დაშიფვრის და ავთენტიფიკაციის გასაღებები

იდეალურ შემთხვევაში, გამოიყენეთ გასაღებები, რომლებიც მიღებულია შემთხვევითობის კრიპტოგრაფიულად ძლიერი წყაროდან. AES-256 საჭიროებს 32 ბაიტს შემთხვევით მონაცემებს ("ნედლი" სტრიქონი - ბიტების თანმიმდევრობა ყოველგვარი კოდირების გამოყენების გარეშე).

თუ აპლიკაცია მუშაობს 5.5 ქვემოთ PHP ვერსიით, რომელსაც არ აქვს ჩაშენებული PBKDF2, მაშინ მოგიწევთ გამოიყენოთ თქვენი საკუთარი იმპლემენტაცია PHP-ში, რომლის მაგალითი შეგიძლიათ იხილოთ აქ: https://defuse. ca/php-pbkdf2.htm. გაითვალისწინეთ, რომ საკუთარ იმპლემენტაციაზე დაყრდნობა შეიძლება არ გადაჭრას გასაღები სწორად, როგორც ამას აკეთებს ჩაშენებული hash_pbkdf2() ფუნქცია.

არ გამოიყენოთ იგივე გასაღები დაშიფვრისა და ავთენტიფიკაციისთვის. როგორც ზემოთ აღინიშნა, დაშიფვრის გასაღებისთვის საჭიროა 32 ბაიტი და ავტორიზაციის გასაღებისთვის (HMAC) 32 ბაიტი. PBKDF2-ით შეგიძლიათ პაროლიდან აიღოთ 64 ბაიტი და გამოიყენოთ, ვთქვათ, პირველი 32 ბაიტი დაშიფვრის გასაღებად, ხოლო დარჩენილი 32 ბაიტი ავტორიზაციის გასაღებისთვის.

თუ თქვენი პაროლები ინახება ფაილში, მაგალითად, HEX სტრიქონის სახით, ნუ დაშიფვრავთ მათ დაშიფვრის ფუნქციების მიწოდებამდე. ამის ნაცვლად, გამოიყენეთ PBKDF2 HEX-შიფრირებული გასაღებების პირდაპირ გადასაყვანად მაღალი ხარისხის დაშიფვრის ან ავტორიზაციის გასაღებად. ან გამოიყენეთ SHA-256 დამატებითი კოდირების გამოსავლის გარეშე (მხოლოდ 32 ბაიტიანი სტრიქონი) პაროლების გასაშლელად. პაროლის რეგულარული ჰეშირების გამოყენება უზრუნველყოფს საკმარის ენტროპიას. დამატებითი დეტალები მოცემულია შემდეგ აბზაცებში.

გასაღების გაჭიმვა

პირველ რიგში, თქვენ უნდა მოერიდოთ დაბალი ენტროპიის კლავიშების გამოყენებას. მაგრამ მაინც, თუ თქვენ გჭირდებათ, მაგალითად, მომხმარებლის პაროლების გამოყენება, მაშინ აუცილებლად უნდა გამოიყენოთ PBKDF2 გამეორებების დიდი რაოდენობით, რათა მაქსიმალურად გაზარდოთ გასაღების უსაფრთხოება.

PBKDF2-ის ერთ-ერთი პარამეტრი არის ჰეშირების გამეორებების რაოდენობა. და რაც უფრო მაღალია ის, მით მეტია გასაღების უსაფრთხოება, რომლის იმედიც შეგიძლიათ. თუ თქვენი კოდი მუშაობს 64-ბიტიან პლატფორმაზე, გამოიყენეთ SHA-512, როგორც ჰეშირების ალგორითმი PBKDF2-ისთვის. 32-ბიტიანი პლატფორმისთვის გამოიყენეთ SHA-256.

ამასთან, შეუძლებელია ონლაინ აპლიკაციებში გამეორებების შედარებით დიდი რაოდენობის გამოყენება DoS შეტევის რისკის გამო. აქედან გამომდინარე, გასაღების ხარისხი არ იქნება ისეთი მაღალი, როგორც ოფლაინ აპლიკაციებში, რომლებსაც შეუძლიათ ასეთი რისკის გარეშე გამეორებების დიდი რაოდენობა. როგორც წესი, ონლაინ აპლიკაციებისთვის, ჰეშირების გამეორებების ასეთი რაოდენობა შეირჩევა ისე, რომ PBKDF2 იღებს არაუმეტეს 100 ms.

თუ თქვენ შეგიძლიათ გამოიყენოთ მაღალი ენტროპიის პაროლები, არ არის აუცილებელი მისი გაჭიმვა, როგორც ამას გააკეთებთ დაბალი ენტროპიის პაროლების შემთხვევაში. მაგალითად, თუ შექმნით "encryption_master_key" და "auth_master_key" /dev/urandom-ის გამოყენებით, მაშინ PBKDF2 საერთოდ არ არის საჭირო. უბრალოდ დარწმუნდით, რომ გამოიყენეთ კლავიშები, როგორც ბიტების თანმიმდევრობა, ყოველგვარი კოდირების გარეშე.

გარდა ამისა, PBKDF2-ით რთული არ არის დაშიფვრის და ავთენტიფიკაციის გასაღებების მიღება ერთი ძირითადი პაროლიდან (უბრალოდ გამოიყენეთ მცირე რაოდენობის გამეორება ან თუნდაც ერთი). ეს სასარგებლოა, თუ თქვენ გაქვთ მხოლოდ ერთი "ძირითადი პაროლი", რომელიც გამოიყენება როგორც დაშიფვრისთვის, ასევე ავთენტიფიკაციისთვის.

გასაღების შენახვა და მართვა

საუკეთესოა გამოიყენოთ ცალკე გამოყოფილი გასაღების შესანახი მოწყობილობა (HSM).

თუ ეს შეუძლებელია, მაშინ შეტევის გასართულებლად შეგიძლიათ გამოიყენოთ გასაღების ფაილის ან კონფიგურაციის ფაილის დაშიფვრა (რომელიც ინახავს რეალურ დაშიფვრის/ავთენტიფიკაციის გასაღებებს) ცალკე ადგილას შენახული გასაღების გამოყენებით (მთავარი დირექტორია ან საიტის ფესვის გარეთ). . მაგალითად, შეგიძლიათ გამოიყენოთ Apache გარემოს ცვლადი httpd.conf-ში, რათა შეინახოთ გასაღები, რომელიც საჭიროა ფაქტობრივი გასაღებების ფაილის გასაშიფრად:
SetEnv keyfile_key crypto_strong_high_entropy_key # შეგიძლიათ ამ ცვლადის წვდომა PHP-ში $_SERVER["keyfile_key"] # დანარჩენი კონფიგურაციის გამოყენებით
ახლა, თუ ფაილები საიტის ძირში და ქვემოთ, მათ შორის ფაილები გასაღებებით, დაზიანებულია (მაგალითად, თუ სარეზერვო ასლი გაჟონა), დაშიფრული მონაცემები უსაფრთხოდ დარჩება, რადგან გარემოს ცვლადში შენახული გასაღები არ არის გატეხილი. მნიშვნელოვანია გვახსოვდეს, რომ httpd.conf ფაილები ცალკე უნდა იყოს სარეზერვო ასლი და არ მოხდეს keyfile_key ცვლადის კომპრომეტირება, მაგალითად, phpinfo(-ის გამომავალი) საშუალებით.

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

მონაცემთა შეკუმშვა

ზოგადად, თქვენ არ უნდა შეკუმშოთ საწყისი ტექსტი მის დაშიფვრამდე. ამან შეიძლება მტერს დამატებითი ინსტრუმენტი მისცეს ანალიზისთვის.

მაგალითად, თუ თქვენ ინახავთ სესიის მონაცემებს დაშიფრულ ქუქი-ფაილებში, რომელთაგან ზოგიერთი არის მომხმარებლის მიერ მოწოდებული და ზოგიერთი წარმოადგენს საიდუმლო ინფორმაციას, მოწინააღმდეგეს შეუძლია გაიგოს დამატებითი ინფორმაცია საიდუმლოს შესახებ, როგორც ჩვეულებრივი მომხმარებელი, სპეციალურად შემუშავებული მონაცემების გაგზავნით და გაზომვა, თუ როგორ იცვლება მიღებული შიფრული ტექსტების სიგრძე.

ტექსტი შეკუმშულია უფრო ეფექტურად, თუ არის განმეორებადი ადგილები. მომხმარებლის მონაცემების მანიპულირებით, შეგიძლიათ აირჩიოთ ის ისე, რომ ნაწილობრივ დაემთხვა საიდუმლო მონაცემებს. რაც უფრო დიდია შესატყვისი, მით უფრო მცირეა გამომავალი შიფრული ტექსტი. ამ ტიპის თავდასხმას კრიმინალი ეწოდება.

თუ თქვენ არ გჭირდებათ მონაცემების შეკუმშვა, ნუ შეკუმშავთ მას.

სერვერის გარემო

როგორც წესი, თქვენ არ უნდა უმასპინძლოთ უსაფრთხოებისადმი მგრძნობიარე აპლიკაციებს საერთო სერვერზე. მაგალითად, საერთო ჰოსტინგზე, სადაც მოწინააღმდეგეს შეუძლია წვდომა ვირტუალურ მანქანაზე იმავე ფიზიკურ სერვერზე, როგორც თქვენ.

არსებობს სხვადასხვა მიზეზი, რაც საერთო სერვერებს საეჭვო ადგილად აქცევს უსაფრთხოებისთვის კრიტიკული აპლიკაციების მასპინძლობისთვის. მაგალითად, ახლახან გამოვლინდა თავდასხმები ვირტუალურ სერვერებს შორის: eprint.iacr.org/2014/248.pdf. ეს კარგი შეხსენებაა, რომ შეტევითი ტექნიკა არ მცირდება, არამედ დროთა განმავლობაში იხვეწება და უმჯობესდება. ასეთი ხარვეზები ყოველთვის უნდა იყოს გათვალისწინებული.

ექსპერტის კონსულტაცია

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

(PHP 4, PHP 5, PHP 7)

crypt - ცალმხრივი სიმებიანი ჰეშირება

გაფრთხილება

ეს ფუნქცია არ არის (ჯერ) ორობითი უსაფრთხო!

აღწერა

საძვალე (სიმებიანი $str [, სიმებიანი $მარილი]): სიმებიანი

საძვალე ()დააბრუნებს ჰეშირებულ სტრიქონს Unix DES-ზე დაფუძნებული სტანდარტული ალგორითმის ან ალტერნატიული ალგორითმების გამოყენებით, რომლებიც შესაძლოა ხელმისაწვდომი იყოს სისტემაში.

მარილის პარამეტრი არჩევითია. თუმცა, საძვალე ()ქმნის სუსტ ჰეშს მარილის გარეშე. PHP 5.6 ან უფრო ახალი ვერსია აჩენს E_NOTICE შეცდომას მის გარეშე. დარწმუნდით, რომ მიუთითეთ საკმარისად ძლიერი მარილი უკეთესი უსაფრთხოებისთვის.

პაროლი_ჰაში()იყენებს ძლიერ ჰეშს, წარმოქმნის ძლიერ მარილს და ავტომატურად იყენებს შესაბამის რაუნდებს. პაროლი_ჰაში()არის მარტივი საძვალე ()შეფუთვა და თავსებადია არსებული პაროლის ჰეშებთან. Გამოყენების პაროლი_ჰაში()წახალისებულია.

ზოგიერთი ოპერაციული სისტემა მხარს უჭერს ერთზე მეტ ტიპის ჰეშს. სინამდვილეში, ზოგჯერ სტანდარტული DES-ზე დაფუძნებული ალგორითმი იცვლება MD5-ზე დაფუძნებული ალგორითმით. ჰეშის ტიპი გამოწვეულია მარილის არგუმენტით. 5.3-მდე, PHP განსაზღვრავს ხელმისაწვდომ ალგორითმებს ინსტალაციის დროს, სისტემის კრიპტის () საფუძველზე. MD5), დამოკიდებულია MD5 crypt() ხელმისაწვდომობაზე. PHP აყენებს მუდმივ სახელს CRYPT_SALT_LENGTHრაც მიუთითებს ხელმისაწვდომი ჰეშების მიერ დაშვებულ ყველაზე ხანგრძლივ მოქმედ მარილს.

სტანდარტული DES-ზე დაფუძნებული საძვალე ()აბრუნებს მარილს, როგორც გამომავალი პირველი ორი სიმბოლო. ის ასევე იყენებს str-ის მხოლოდ პირველ რვა სიმბოლოს, ამიტომ უფრო გრძელი სტრიქონები, რომლებიც იწყება იგივე რვა სიმბოლოთი, გამოიმუშავებს იგივე შედეგს (როდესაც იგივე მარილი გამოიყენება).

სისტემებზე, სადაც crypt() ფუნქცია მხარს უჭერს რამდენიმე ჰეშის ტიპს, შემდეგი მუდმივები დაყენებულია 0-ზე ან 1-ზე, იმისდა მიხედვით, ხელმისაწვდომია თუ არა მოცემული ტიპი:

CRYPT_STD_DES- სტანდარტული DES-ზე დაფუძნებული ჰეში ორი სიმბოლოს მარილით ანბანიდან "./0-9A-Za-z". Salt-ში არასწორი სიმბოლოების გამოყენება გამოიწვევს crypt()-ის წარუმატებლობას.
CRYPT_EXT_DES- გაფართოებული DES-ზე დაფუძნებული ჰეში. "salt" არის 9-სიმბოლოიანი სტრიქონი, რომელიც შედგება ქვედა ხაზისგან, რასაც მოჰყვება 4 ბაიტი გამეორების რაოდენობა და 4 ბაიტი მარილი. ისინი დაშიფრულია როგორც დასაბეჭდი სიმბოლოები, 6 ბიტი თითო სიმბოლოზე, პირველ რიგში ყველაზე ნაკლებად მნიშვნელოვანი სიმბოლო. მნიშვნელობები 0-დან 63-მდე დაშიფრულია როგორც "./0-9A-Za-z". Salt-ში არასწორი სიმბოლოების გამოყენება გამოიწვევს crypt()-ის წარუმატებლობას.
CRYPT_MD5- MD5 ჰეშირება თორმეტი სიმბოლოს მარილით დაწყებული $1$-ით
CRYPT_BLOWFISH- Blowfish-ის ჰეშირება მარილით შემდეგნაირად: "$2a$", "$2x$" ან "$2y$", ორნიშნა ღირებულების პარამეტრი, "$" და 22 სიმბოლო ანბანიდან "./0-9A- ზა-ზ“. ამ დიაპაზონის გარეთ სიმბოლოების გამოყენება salt-ში გამოიწვევს crypt()-ს ნულოვანი სიგრძის სტრიქონის დაბრუნებას. ორნიშნა ღირებულების პარამეტრი არის Blowfish-ზე დაფუძნებული ჰეშირების ალგორითმისთვის განმეორებითი რაოდენობის საბაზისო-2 ლოგარითმი და უნდა იყოს 04-31 დიაპაზონში, ამ დიაპაზონის გარეთ არსებული მნიშვნელობები გამოიწვევს crypt()-ის წარუმატებლობას. PHP-ის ვერსიები 5.3.7-მდე მხარს უჭერს მხოლოდ "$2a$"-ს, როგორც მარილის პრეფიქსი: PHP 5.3.7-მა შემოიღო ახალი პრეფიქსები, რათა გამოესწორებინა უსაფრთხოების სისუსტე Blowfish-ის განხორციელებაში. გთხოვთ, მიმართოთ უსაფრთხოების შესწორების სრულ დეტალებს, მაგრამ შეჯამებისთვის, დეველოპერებმა, რომლებიც მიზნად ისახავს მხოლოდ PHP 5.3.7 და უფრო ახალ ვერსიას, უნდა გამოიყენონ „$2y$“ უპირატესობა „$2a$“-ზე.
CRYPT_SHA256- SHA-256 ჰეში თექვსმეტი სიმბოლოს მარილით, პრეფიქსით $5$. თუ მარილის სტრიქონი იწყება "rounds=-ით".
CRYPT_SHA512- SHA-512 ჰეში თექვსმეტი სიმბოლოს მარილით, პრეფიქსით $6$. თუ მარილის სტრიქონი იწყება "rounds=-ით". $", N-ის რიცხვითი მნიშვნელობა გამოიყენება იმის დასადგენად, თუ რამდენჯერ უნდა შესრულდეს ჰეშირების მარყუჟი, ისევე როგორც ხარჯების პარამეტრი Blowfish-ზე. რაუნდების ნაგულისხმევი რაოდენობა არის 5000, არის მინიმუმ 1000 და მაქსიმუმ 999,999,999. N-ის ნებისმიერი არჩევანი ამ დიაპაზონის გარეთ შეიკვეცება უახლოეს ლიმიტამდე.

PHP 5.3.0-დან გამომდინარე, PHP შეიცავს საკუთარ იმპლემენტაციას და გამოიყენებს მას, თუ სისტემას არ აქვს მხარდაჭერა ერთი ან მეტი ალგორითმისთვის.

Პარამეტრები

სტრიქონი გასასწორებელი.

Სიფრთხილით

Გამოყენებით CRYPT_BLOWFISHალგორითმი, გამოიწვევს str პარამეტრის შეკვეცას მაქსიმუმ 72 სიმბოლომდე.

სურვილისამებრ მარილის სტრიქონი ჰეშინგის დასაფუძნებლად. თუ არ არის გათვალისწინებული, ქცევა განისაზღვრება ალგორითმის განხორციელებით და შეიძლება გამოიწვიოს მოულოდნელი შედეგები.

დაბრუნების ღირებულებები

აბრუნებს ჰეშირებულ სტრიქონს ან სტრიქონს, რომელიც 13 სიმბოლოზე მოკლეა და გარანტირებულია, რომ განსხვავდება მარილისგან წარუმატებლობის შემთხვევაში.

გაფრთხილება

პაროლების ვალიდაციისას, სტრიქონების შედარების ფუნქცია, რომელიც არ არის დაუცველი დროის შეტევების მიმართ, უნდა იქნას გამოყენებული გამომავალი შედარებისთვის. საძვალე ()ადრე ცნობილ ჰეშს. PHP 5.6 და შემდეგ უზრუნველყოფს hash_equals()ამ მიზნით.

ცვლილებების ჟურნალი

ვერსია	აღწერა
5.6.5	როდესაც წარუმატებლობის სტრიქონი "0" მოცემულია როგორც salt, "1" ახლა დაბრუნდება კრიპტის სხვა განხორციელებებთან შესაბამისობისთვის. ამ ვერსიამდე PHP 5.6 არასწორად დააბრუნებდა DES ჰეშს.
5.6.0	გახსენით E_NOTICE უსაფრთხოების გაფრთხილება, თუ მარილი გამოტოვებულია.
5.5.21	როდესაც წარუმატებლობის სტრიქონი "0" მოცემულია როგორც salt, "1" ახლა დაბრუნდება კრიპტის სხვა განხორციელებებთან შესაბამისობისთვის. ამ ვერსიამდე, PHP 5.5 (და უფრო ადრეული ფილიალები) არასწორად აბრუნებდა DES ჰეშს.
5.3.7	დამატებულია $2x$და $2y$ Blowfish რეჟიმები, რომ გაუმკლავდეთ პოტენციურ მაღალი ბიტიან შეტევებს.
5.3.2	დამატებულია SHA-256 და SHA-512 კრიპტა ულრიხ დრეპერის » განხორციელების საფუძველზე.
5.3.2	დააფიქსირა Blowfish-ის ქცევა არასწორ რაუნდებზე, რათა დაბრუნდეს "მარცხი" სტრიქონი ("0" ან "1"), ნაცვლად DES-ზე დაბრუნების.
5.3.0	PHP ახლა შეიცავს საკუთარ იმპლემენტაციას MD5 crypt, Standard DES, Extended DES და Blowfish ალგორითმებისთვის და გამოიყენებს ამას, თუ სისტემას არ აქვს მხარდაჭერა ერთი ან რამდენიმე ალგორითმისთვის.

მაგალითები

მაგალითი #1 საძვალე ()მაგალითები

$hashed_password = crypt("mypassword"); // დაე, მარილი ავტომატურად წარმოიქმნას

/* თქვენ უნდა გადასცეთ crypt()-ის მთელი შედეგები, როგორც მარილი a-ს შედარებისთვის
პაროლი, რათა თავიდან აიცილოთ პრობლემები ჰეშირების სხვადასხვა ალგორითმის გამოყენებისას. (როგორც
ზემოთ ნათქვამია, DES-ზე დაფუძნებული პაროლის სტანდარტული ჰეშირება იყენებს 2-სიმბოლოიან მარილს,
მაგრამ MD5-ზე დაფუძნებული ჰეშინგი იყენებს 12.) */
if (hash_equals ($hashed_password, crypt ($user_input, $hashed_password))) (
echo "პაროლი დადასტურებულია!" ;
}
?>

მაგალითი #2 გამოყენება საძვალე () htpasswd-ით

// დააყენეთ პაროლი
$password = "mypassword" ;

// მიიღეთ ჰეში, ნება მიეცით მარილი ავტომატურად წარმოიქმნას
$hash = crypt ($პაროლი);
?>

მაგალითი #3 გამოყენება საძვალე ()სხვადასხვა ტიპის ჰეშით

/* ეს მარილები მხოლოდ მაგალითებია და არ უნდა იქნას გამოყენებული სიტყვასიტყვით თქვენს კოდში.
თქვენ უნდა შექმნათ განსხვავებული, სწორად ფორმატირებული მარილი თითოეული პაროლისთვის.
*/
თუ (CRYPT_STD_DES == 1) (
echo "სტანდარტული DES:" . საძვალე ("rasmuslerdorf", "rl"). "\n" ;
}

თუ (CRYPT_EXT_DES == 1) (
echo "გაფართოებული DES:" . საძვალე ("rasmuslerdorf" , "_J9..rasm"). "\n" ;
}

თუ (CRYPT_MD5 == 1) (
ექო "MD5:" . საძვალე ("rasmuslerdorf", "$1$rasmusle$"). "\n" ;
}

თუ (CRYPT_BLOWFISH == 1) (
echo "Blowfish:" . crypt("rasmuslerdorf" , "$2a$07$usesomesillystringforsalt$") . "\n" ;
}

თუ (CRYPT_SHA256 == 1) (
ექო "SHA-256:" . crypt ("rasmuslerdorf" , "$5$rounds=5000$usesomesillystringforsalt$") . "\n" ;
}

თუ (CRYPT_SHA512 == 1) (
ექო "SHA-512:" . crypt ("rasmuslerdorf" , "$6$rounds=5000$usesomesillystringforsalt$") . "\n" ;
}
?>

ნებისმიერი ინფორმაციის დაშიფვრა ან გაშიფვრა შესაძლებელია, მათ შორის PHP-ის გამოყენებით. ამ ენას აქვს მონაცემთა დაშიფვრის მრავალი შესაძლებლობა, მარტივიდან რთულამდე.

მოდით შევხედოთ დაშიფვრის ძირითად მეთოდებს

ბაზა64- საშუალებას გაძლევთ დაშიფროთ და გაშიფროთ მონაცემები MIME base64 ალგორითმის გამოყენებით. ის არ იყენებს გასაღებებს და ხშირად გამოიყენება PHP-ში ბმულების დასამალად.

მაგალითები:
//ტექსტის დაშიფვრა
$text = "ბმული";
echo base64_encode($text); //აწარმოებს: PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==
//გაშიფვრა
echo base64_decode("PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==");
?>

როგორც ხედავთ, ჩვენ პირველად გამოვიყენეთ base64_encode ოპერაცია და მივიღეთ შიფრი: PGEgaHJlZj0iIyI+0KHRgdGL0LvQutCwPC9hPg==, და შემდეგ ჩაანაცვლა იგი base64_decode-ში და დააბრუნა ბმული.

md5- საშუალებას გაძლევთ ცალმხრივად დააფიქსიროთ მონაცემები. ანუ, base64-ისგან განსხვავებით, თქვენ ვეღარ შეძლებთ მათ უკან გაშიფვრას. ხშირად md5 გამოიყენება მონაცემთა ბაზაში პაროლების შესანახად, მაგრამ ახლახანს დაშიფრული md5 კომბინაცია გახდა ადვილი საპოვნელი დეშიფრაციის ცხრილებში, რომლებიც კეთილგანწყობილია მრავალი საიტისა და ალგორითმის მიერ. ამიტომ md5 პაროლების შესანახად უმჯობესია ალგორითმები Blowfish-ით ჩაანაცვლოთ.

მაგალითი:

//ტექსტის დაშიფვრა
echo md5 ("კომბინაცია");
?>

გასაღების დაშიფვრა

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

ფუნქცია __encode ($text, $key) (

$enc_text=base64_encode(mcrypt_generic($td,$iv.$text));
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
დაბრუნება $enc_text; ))
ფუნქცია strToHex($string) (
$hex="";
ამისთვის ($i=0; $i< strlen($string); $i++) { $hex .= dechex(ord($string[$i])); }
დაბრუნება $hex; )
ფუნქცია __decode ($text, $key) (
$td = mcrypt_module_open("tripledes", "", "cfb", "");
$iv_size = mcrypt_enc_get_iv_size($td);
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
if (mcrypt_generic_init ($td, $key, $iv) != -1) (
$decode_text = substr(mdecrypt_generic($td, base64_decode($text)),$iv_size);
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
დააბრუნეთ $decode_text; ))
ფუნქცია hexToStr ($ hex) (
$string="";
ამისთვის ($i=0; $i< strlen($hex)-1; $i+=2) { $string .= chr(hexdec($hex[$i].$hex[$i+1])); }
დააბრუნეთ $string; )

$str = "ფუნთუშები, რომლებიც უნდა იყოს დაშიფრული!
გასაღებით";
$code = strToHex(__encode($str, "My#key-do-36-simvolov"));
echo "დაშიფრული კოდი: ".$code."
";

$str = __decode(hexToStr($code), "My#key-do-36-simvolov");
echo "გაშიფრული კოდი: ".$str."
";
?>

შეგიძლიათ დაშიფროთ html შინაარსი. გასაღების სიგრძე არ უნდა აღემატებოდეს 36 სიმბოლოს.

ეს მეთოდი შეიძლება გამოყენებულ იქნას ზოგიერთი მონაცემის დაშიფვრისთვის და txt ფაილში ან მონაცემთა ბაზაში განთავსებისთვის და გასაღებით გაშიფვრის გამოყენებით.

რა თქმა უნდა, ნებისმიერი კოდის გაშიფვრა/გატეხვა შესაძლებელია და ეს არ არის გამონაკლისი, ამიტომ გამოიყენეთ დაშიფვრის ძლიერი მეთოდები.

კრიპტოგრაფიის ერთ-ერთი ძირითადი ჭეშმარიტება ის არის, რომ თქვენ არ უნდა გამოიგონოთ არაფერი ამ სფეროში, თუ არ ხართ პროფესიონალი. ეს ნაწილობრივ მართალია, რადგან ყველაფერი საუკეთესო დიდი ხანია გამოიგონეს, განიცადეს და გამოიყენეს ათწლეულების განმავლობაში ინფორმაციული ტექნოლოგიების სფეროში. სიმართლის მეორე მხარე ის არის, რომ ცოდნის გარკვეული სფეროს განვითარება ხდება მხოლოდ მასში ახალი იდეებისა და ორიგინალური გადაწყვეტილებების მუდმივი შემოდინებით.

გასაგები მიზეზების გამო, ჩვენ არ მივიღებთ მიზნად ინდუსტრიული კრიპტოგრაფიის გიგანტებს, როგორიცაა AES, არამედ ჩავძირავთ, ასე ვთქვათ, ჩვენს კრიპტოგრაფიულ კვლევაში ბლექჯეკითა და სიხარულით.

ნაწილობრივ იმიტომ, რომ საინტერესოა, ნაწილობრივ იმიტომ, რომ საკუთარი რაღაცის მოდელირება და აღიარებულ სტანდარტებთან შედარება, თქვენ ნათლად ხედავთ კონტრასტს, ეფექტურ გადაწყვეტილებებს და აშკარა გამოტოვებებს და გესმით, რისკენ შეგიძლიათ ისწრაფოთ ეფექტურობის გასაუმჯობესებლად.

მაგრამ წყალი უკვე საკმარისია.

ვთქვათ, ჩვენი ვებ აპლიკაცია დაწერილია PHP-ში, საჭიროებს შექცევად დაშიფვრას და გვჯერა, რომ შეგვიძლია დავწეროთ ჩვენი საკუთარი შიფრული სისტემა.

მოდით დავწეროთ ჩვენი შექცევადი დაშიფვრის სისტემა პირადი და საჯარო გასაღებებით, რომელსაც ექნება მეტ-ნაკლებად უსაფრთხო კრიპტოგრაფიული ალგორითმის შემდეგი მახასიათებლები:

ხმაურის სიმბოლოების არსებობა საბოლოო შიფრში.
ინფორმაცია გამგზავნი-დანიშნულების თითოეულ არხზე დაშიფრული იქნება პირადი გასაღების გამოყენებით და შესაბამისი ფუნქცია უნიკალური იქნება თითოეული გასაღებისთვის.
თითოეული შეტყობინება მიიღებს დაიჯესტის კოდს - უნიკალური კოდი, რომელიც არის პირადი გასაღებისა და ორიგინალური შეტყობინების ფუნქცია. ეს საჭიროა "წყაროს სიმბოლოს" შესატყვისი ფუნქციის უნიკალურობის მისაღწევად<=>კოდირებული სიმბოლო“ არა მხოლოდ „გამგზავნი-მიმღების“ არხისთვის, არამედ თითოეული ინდივიდუალური შეტყობინებისთვის.
ამრიგად, მაშინაც კი, თუ წარმოვიდგენთ, რომ კოდირებული და ორიგინალური სიმბოლოების შესაბამისობა კონკრეტული შეტყობინებისთვის ცნობილი გახდა კრიპტოგრაფიული ანალიზის გამოყენებით, მაგალითად, სიხშირის ანალიზით, ეს არ იძლევა რაიმე უპირატესობას სხვა შეტყობინების შესწავლისას.
სიხშირის ანალიზის გასართულებლად, ჩვენ დავშიფვრავთ თითოეული საწყისი შეტყობინების სიმბოლოს ორი შიფრული სიმბოლოთი.

მერე რა მოხდა.

სინამდვილეში, თქვენ შეგიძლიათ ნახოთ საბოლოო შედეგი

SymCoder კლასი მოიცავს დაშიფვრის და გაშიფვრის მეთოდებს.

დაშიფვრა ხორციელდება code() მეთოდით, რომელიც იღებს თავდაპირველ შეტყობინებას შეყვანად.

აქ, გენერირებული კორესპონდენციის ცხრილიდან შეტყობინება tab_coded-ში ქმნის დაშიფრულ შეტყობინებას, რომელიც განზავებულია კიდეების გასწვრივ და შიგნით ხმაურის სიმბოლოებით.

სხვათა შორის, ხმაურის სიმბოლოები უნიკალურია თითოეული გამგზავნი-დანიშნულების არხისთვის, რადგან ისინი წარმოიქმნება არხის გასაღების გამოყენებით, მაგრამ არ არის უნიკალური შეტყობინებებისთვის. კოდის_სიმბოლოებში დაშიფვრისთვის გამოყენებული სიმბოლოები არის პუნქტუაციის ნიშნები და სიმბოლოები, როგორიცაა % @ და ა.შ.

თითოეული დაშიფრული სიმბოლოსთვის არის ორი სიმბოლო code_symbols-დან, გასაგები მიზეზების გამო, რომ მათში რამდენჯერმე ნაკლებია კოდირებულ სიმბოლოებზე.

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

მაგალითად, "გამარჯობა სამყაროს" შეტყობინება, როდესაც დაშიფრულია, ასე გამოიყურება:

დაიჯესტი-a00bf11d-&?==&!&?.@.@=!=-.?&1.#&?=:.:.1%!&-%@&@%~&1^#=?%% .!%+.?.~=?..&?%&&:%~.#%@&1&1.#=?.#.?.!&1==&=.-=!

და აქ არის იგივე შეტყობინება, ისევ კოდირებული:

დაიჯესტი-a00bf11d-=:.?=:&!.?.1&-=:=?.?.=.?.!&=%!=-%@=!%~.=^#.1%%. !%+=:.~.@..==%&&1%~.1%@=?.@.!&=.!&@=:&1.==:=!.1&:

ჩანს, რომ ერთი და იგივე გზავნილის დაიჯესტი იგივეა, მაგრამ შიფრი განსხვავებული ხდება - ხმაურის სიმბოლოები ემატება თვითნებურად და თვითნებური თანმიმდევრობით ყოველი ახალი დაშიფვრისთვის.

შეტყობინებებს აქვს ჭარბი რაოდენობა, რომელიც მცირდება შეტყობინების მოცულობის მატებასთან ერთად, 10%-მდე ხმაური (ყველაზე მოკლე შეტყობინებებისთვის ხმაური აღწევს 90%-ს ან მეტ პროცენტს), დაშიფრული შეტყობინების მინიმალური სიგრძეა 116 სიმბოლო. დაშიფვრის ამ მეთოდის ერთ-ერთი მინუსი არის ის, რომ დაშიფრული შეტყობინებები მინიმუმ გაორმაგებულია.

გაშიფვრა შედგება ფორმის „კოდის სიმბოლოს“ საპირისპირო თარგმანისგან - ორიგინალური სიმბოლო, ხმაურით ამოღებული შეტყობინებისგან. რა შეიძლება იყოს გასაღები? ძირითადად, ნებისმიერი სტრიქონი, რომელიც უნიკალურია თითოეული დანიშნულება-მიმღების წყვილისთვის.

მაგალითად, თუ თქვენ ქმნით მესინჯერს შეტყობინების დაშიფვრით, მაშინ პირადი გასაღების უმარტივესი ვერსია შეიძლება იყოს md5($user_id_1. $salt. $user_id_2), მაშინ გასაღები უნიკალური იქნება თითოეული შეტყობინების არხისთვის.

ვთქვათ, თქვენ გჭირდებათ მონაცემების გაცვლა ორ სერვერს შორის. მონაცემების დასაცავად ტრაფიკის მოსმენისგან, მონაცემები დაშიფრულია. მაგალითად, მოქმედებების გადატანა ბოტნეტში. ეს არის ის, რაც არსებითად არ არის დაშიფვრა, არამედ ეწოდება კოდირება და ცნობილი ფუნქციები გამოიყენება ასეთი კოდის გაშიფვრისთვის.

როგორც ფსევდო დაშიფვრის კიდევ ერთი მაგალითი, მე მივცემ პაროლების „დაშიფვრის“ მაგალითს ერთი CMS-ის მონაცემთა ბაზაში - იქ პაროლები არ არის დაშიფრული md5() ან , არამედ უბრალოდ დაშიფრულია base64-ის საშუალებით. იმათ. როდესაც მონაცემთა ბაზის გაჟონვა ხდება, ჰაკერს არ გაუჭირდება ყველა პაროლის გაშიფვრა ჩაშენებული PHP ფუნქციის base64_decode() გამოყენებით.

ჩვენ უნდა გადავცეთ მონაცემები ისე, რომ ვინმე შეძლებს ტექსტის ჩაჭრას და მის გაშიფვრას. PHP-ს აქვს მონაცემთა დაშიფვრის პოპულარული პაკეტი სახელწოდებით Mcrypt, რომელიც უზრუნველყოფს ორმხრივ დაშიფვრას (ანუ მონაცემთა რეალურ დაშიფვრას და გაშიფვრას).

Mcrypt ვერსია 2.4.7 მხარს უჭერს შემდეგი სიმეტრიული დაშიფვრის ალგორითმებს: Blowfish, RC2, Safer-sk64 xtea, Cast-256, RC4, Safer-sk128, DES, RC4-iv, Serpent, Enigma, Rijndael-128, Threeway, Rijndael-1 , TripleDES, LOKI97, Rijndael-256, Twofish, Panama, Saferplus და ა.შ. მეტი დეტალი თითოეული ალგორითმის შესახებ წერია ვიკიპედიაში.

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

სტრიქონის დაშიფვრისა და გაშიფვრის მაგალითი

mcrypt_module_open("des", "", "ecb", "")
ეს ფუნქცია ხსნის ალგორითმის მოდულს და გამოყენებულ რეჟიმს. ამ მაგალითისთვის, DES ალგორითმი არის ECB რეჟიმში.

$key = substr($key, 0, mcrypt_enc_get_key_size($td));
გასაღების მაქსიმალური ზომა უნდა მივიღოთ mcrypt_enc_get_key_size() ფუნქციის გამოძახებით და ამაზე ნაკლები მნიშვნელობა სწორი იქნება.

$s = mcrypt_generic ($td, $source);
დაშიფვრისას, მონაცემები ივსება ნულოვანი ბაიტით, რათა უზრუნველყოფილ იქნას მონაცემების n*ბლოკის ზომის სიგრძე. ბლოკის ზომის ბლოკის ზომა განისაზღვრება ალგორითმით (DES-ისთვის ბლოკის ზომა არის 64 ბიტი). ამიტომ, გაშიფვრისას, ხაზის ბოლოს შეიძლება გამოჩნდეს „\0“, რომელიც ამოღებულია trim() ფუნქციით.