នេះគឺជាមធ្យោបាយដែលមានតម្លៃសមរម្យ និងសុវត្ថិភាពក្នុងការទូទាត់ថ្លៃទំនិញ និងសេវាកម្មតាមអ៊ីនធឺណិត។ បន្ថែមប្រព័ន្ធដំណើរការសម្រាប់ប្រព័ន្ធនេះទៅហាងអនឡាញរបស់អ្នក ហើយទទួលយកការទូទាត់ដោយមិនពន្យារពេល។

ពិធីការ Yandex.Money 3.0 ដែលបានអាប់ដេតអនុញ្ញាតឱ្យអ្នកប្រើប្រភេទផ្សេងគ្នានៃការទូទាត់៖

• តាមពិត ប្រាក់ Yandex;
• កាតធនាគារ;
• ការទូទាត់តាមរយៈស្ថានីយ;
• ការទូទាត់តាមទូរស័ព្ទ។

លើសពីនេះទៀតនីតិវិធីសម្រាប់ការតភ្ជាប់ហាងដែលបានបង្កើតនៅលើវេទិកា 1C-Bitrix៖ ការគ្រប់គ្រងគេហទំព័រ,ទៅ Yanedex.Money ត្រូវបានសម្រួលយ៉ាងសំខាន់។ អ្នកត្រូវទុកសំណើនៅលើគេហទំព័រ Yandex.Money (ចង្អុលបង្ហាញនៅក្នុងមតិយោបល់ដែលគេហទំព័ររបស់អ្នកបើក ជា​មួយ​នឹង​កំណែ​ពិធីការ 3.0.) ហើយ​បំពេញ​ទម្រង់​បែបបទ​សាមញ្ញ (មាន​តែ 3 វាល)។

ដើម្បីភ្ជាប់ពិធីការ Yandex.Money ថ្មីនៅក្នុងហាងអនឡាញនៅលើវេទិកា 1C-Bitrix អ្នកត្រូវបង្កើតប្រព័ន្ធទូទាត់ថ្មី ហើយជ្រើសរើសប្រព័ន្ធដំណើរការ

ពិនិត្យមើលថាតើគេហទំព័ររបស់អ្នកឆ្លើយតបដោយប្រើពិធីការ https ដែរឬទេ។ នេះគឺជាតម្រូវការជាមុនសម្រាប់ការទទួលយកការទូទាត់ដោយប្រើពិធីការ Yanedex.Money 3.0 ។

អ្នកអាចប្រើវិញ្ញាបនបត្រ SSL ដែលបានចុះហត្ថលេខាដោយខ្លួនឯង ឬម៉ាស៊ីននិម្មិតរបស់យើង ដែលអ្វីៗគ្រប់យ៉ាងត្រូវបានកំណត់រចនាសម្ព័ន្ធរួចហើយ។

បន្ទាប់, ចង្អុលបង្ហាញ លេខសម្គាល់ហាងនៅក្នុងមជ្ឈមណ្ឌលដំណើរការកណ្តាល, លេខបង្អួចហាងនៅក្នុងមជ្ឈមណ្ឌលដំណើរការកណ្តាលដែលអ្នកត្រូវតែទទួលបានពី Yandex នៅពេលបញ្ចប់កិច្ចព្រមព្រៀង និង ពាក្យសម្ងាត់ហាង (shopPassword)ពីទម្រង់ Yandex របស់ហាង។

សម្រាប់ប្រភេទនៃការទូទាត់នីមួយៗ អ្នកនឹងត្រូវបង្កើតដំណើរការផ្ទាល់ខ្លួនរបស់អ្នក ហើយជ្រើសរើសប្រភេទការទូទាត់ដែលត្រូវការ។

ដើម្បីសាកល្បងការទូទាត់ អ្នកត្រូវដាក់តម្លៃ “Y” នៅក្នុងវាល របៀប​ធ្វើ​តេ​ស្ត. នៅពេលអ្នកដាក់ស្នើកម្មវិធីដើម្បីភ្ជាប់ទៅពិធីការ Yandex.Money 3.0 អ្នកនឹងទទួលបានតំណពិសេសមួយ ដោយប្រើដែលអ្នកអាចបញ្ចូលទឹកប្រាក់ក្នុងកាបូបរបស់អ្នកសម្រាប់ការធ្វើតេស្តជាមួយនឹង 1000 rubles ។

នៅក្នុងការកំណត់នៃម៉ូឌុលហាងអនឡាញ អ្នកអាចកំណត់ឡើងវិញនូវផ្លូវទៅកាន់ទំព័រដែលមានសារអំពីការបង់ប្រាក់ជោគជ័យ ឬកំហុស។

ទាំងអស់។ ការដំឡើងត្រូវបានបញ្ចប់

អតិថិជនដែលបានភ្ជាប់កំណែមុនរបស់ Yandex.Money (1.6) មិនចាំបាច់ដំឡើងកំណែទៅកំណែ 3.0 ទេ។ ទាំងនោះ។ កំណែទាំងពីរត្រូវបានគាំទ្រដោយទាំង Yandex.Money និង 1C-Bitrix: ការគ្រប់គ្រងគេហទំព័រ។ ប៉ុន្តែកំណែ 1.6 មិនបន្ថែមសមត្ថភាពក្នុងការប្រើការទូទាត់ក្រៅពី Yandex.Money ទេ។ អតិថិជនថ្មីនៃប្រព័ន្ធទូទាត់នេះត្រូវបានភ្ជាប់ដោយប្រើពិធីការ 3.0 ។

នៅក្នុងការចែកចាយផលិតផល 1C-Bitrix៖ ការគ្រប់គ្រងគេហទំព័រដំណើរការ Yandex.Money (3.0) នឹងត្រូវបានចេញផ្សាយនៅក្នុងកំណែ 14.0.0 នៃម៉ូឌុលហាងអនឡាញ (លក់) ។ មុនពេលអាប់ដេតនេះត្រូវបានចេញផ្សាយ (យើងសន្មត់ថាវានឹងចេញជាអាល់ហ្វានៅចុងខែ) អ្នកដោះស្រាយអាចត្រូវបានស្នើសុំតាមរយៈជំនួយបច្ចេកទេស។

នៅក្នុងយុគសម័យគេហទំព័រទំនើប គេហទំព័រភាគច្រើនកាន់តែមានអន្តរកម្មកាន់តែច្រើនឡើង។ ប្រសិនបើពីមុន ដើម្បីទទួលបានទិន្នន័យដែលបានអាប់ដេត យើងត្រូវធ្វើឱ្យទំព័រទាំងមូលឡើងវិញ ឥឡូវនេះបច្ចេកវិទ្យាបានបង្ហាញខ្លួន ដែលអនុញ្ញាតឱ្យយើងមិនផ្ទុកទំព័រទាំងមូល ប៉ុន្តែមានតែផ្នែកដាច់ដោយឡែករបស់វាប៉ុណ្ណោះ។ ផ្ទុយទៅវិញ វាផ្តល់ភាពងាយស្រួលដល់អ្នកប្រើប្រាស់ និងម្ចាស់ម៉ាស៊ីនមេ ព្រោះទំព័រនឹងផ្ទុកលឿនជាងមុនសម្រាប់អ្នកប្រើប្រាស់ ដោយសារមានតែផ្នែកដាច់ដោយឡែកនៃទំព័រប៉ុណ្ណោះដែលត្រូវបានផ្ទុក ហើយម៉ាស៊ីនមេមិនចាំបាច់បង្កើតទំព័ររាល់ពេល ហើយផ្តល់ឱ្យវាទៅ អ្នកប្រើប្រាស់។ លក្ខណៈពិសេសទាំងនេះមានភាពងាយស្រួលក្នុងការអនុវត្តដោយប្រើ php និង ajax ។

ថ្ងៃនេះយើងនឹងពិនិត្យមើលឧទាហរណ៍តូចមួយដើម្បីយល់កាន់តែច្បាស់អំពីរបៀបដែលគំនិត AJAX ដំណើរការ។ ពេលខ្លះវាពិបាកសម្រាប់អ្នកចាប់ផ្តើមដំបូងក្នុងការយល់ដឹងពីរបៀបដែល php និង ajax ទាក់ទងគ្នាទៅវិញទៅមក មនុស្សជាច្រើនកំពុងស្វែងរកឧទាហរណ៍អំពីរបៀបធ្វើឱ្យទម្រង់មានសុពលភាពដោយមិនផ្ទុកទំព័រទាំងមូលឡើងវិញ។ ខ្ញុំនឹងបង្ហាញអ្នកដោយសង្ខេបអំពីរបៀបដែលវាត្រូវបានធ្វើ ដូច្នេះអ្នកអាចយល់អំពីមូលដ្ឋាន និងគោលការណ៍ដែលនឹងអនុញ្ញាតឱ្យអ្នកធ្វើជាម្ចាស់ឧបករណ៍ផ្សេងទៀតបានយ៉ាងឆាប់រហ័ស និងសរសេរស្គ្រីបផ្ទាល់ខ្លួនរបស់អ្នកនាពេលអនាគត។

ចូរយើងមកជាមួយនឹងកិច្ចការតូចមួយសម្រាប់ខ្លួនយើង យើងនឹងពិនិត្យមើលវត្តមាននៃអាសយដ្ឋានអ៊ីមែលនៅក្នុងមូលដ្ឋានទិន្នន័យដោយមិនចាំបាច់ផ្ទុកទំព័រឡើងវិញដោយប្រើ php និង ajax ។ ឧទាហរណ៍នេះនឹងបង្ហាញយ៉ាងច្បាស់ពីរបៀបដែលយើងអាចធ្វើអន្តរកម្មជាមួយម៉ាស៊ីនមេដោយមិនចាំបាច់ផ្ទុកទំព័រឡើងវិញនៅក្នុងកម្មវិធីរុករក ហើយជារឿយៗវាត្រូវបានគេប្រើសម្រាប់ប្រភេទផ្សេងៗនៃសុពលភាពទម្រង់អ្នកប្រើប្រាស់។ នៅក្នុងថត root យើងនឹងបង្កើតឯកសារចំនួន 3 ដែលមានឈ្មោះថា index.php, email.php, validate.js ។

ការបង្កើតទំព័រ

ចូរយើងបង្កើតទំព័រសាមញ្ញមួយជាមួយនឹងទម្រង់មួយដែលមានវាលតែមួយសម្រាប់បញ្ចូលអ៊ីមែល។
វាក្យសម្ព័ន្ធឯកសារ index.php

ការបង្រៀន AJAX

មធ្យោបាយងាយស្រួលបំផុតដើម្បីធ្វើការជាមួយ AJAX គឺដើម្បីភ្ជាប់ jQuery framework ដែលជាអ្វីដែលខ្ញុំបានធ្វើ។ jQuery ផ្តល់ឱ្យយើងនូវវាក្យសម្ព័ន្ធដែលងាយយល់ និងងាយស្រួលប្រើសម្រាប់ការផ្ញើសំណើ AJAX ដូច្នេះហេតុអ្វីបានជាមិនទាញយកអត្ថប្រយោជន៍ពីវា?

ការបង្កើតអក្សរ js

វាក្យសម្ព័ន្ធនៃឯកសារ validate.js

$(document).ready(function())(var email = ""; $("#email").keyup(function())(var value = $(this).val(); $.ajax(( ប្រភេទ៖ "POST", url:"email.php", data:"email="+value, success:function(msg)( if(msg == "valid")($("#message").html( "អ៊ីមែលនេះអាចប្រើបាន។ អ៊ីមែលនេះត្រូវបានយករួចហើយ។"); ) ) ) )); "សូមដាក់ទិន្នន័យទៅកាន់អ៊ីមែលទាំងអស់"); )else( $.ajax(( type: "POST", url:"email.php", data:"add_email="+email, success:function(msg)($ ("#សារ" .html(msg);

កម្មវិធីគ្រប់គ្រង PHP

ស្គ្រីបនេះនឹងទទួលបានសំណើ POST ពីអតិថិជន ដំណើរការវា និងត្រឡប់លទ្ធផល។ AJAX អានលទ្ធផល និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើវា។
វាក្យសម្ព័ន្ធឯកសារ Email.php

$connection = mysqli_connect("localhost","email","email","email"); if(isset($_POST["email"]) && $_POST["email"] != "")( $email = $_POST["email"]; $email = mysqli_real_escape_string($connection,$email); ប្រសិនបើ (!filter_var($email, FILTER_VALIDATE_EMAIL))( echo "invalid"; )else($sql = "SELECT id FROM email WHERE email="$email""; $result = mysqli_query($connection,$sql); if( mysqli_num_rows($result) == 1)( echo "invalid"; )else(echo "valid"; ) )) if(isset($_POST["add_email"]) && $_POST["add_email"] !="" )( $email = mysqli_real_escape_string($connection, $_POST["add_email"]); $sql = "បញ្ចូលក្នុងអ៊ីមែល(email) VALUES("$email")"; if(mysqli_query($connection,$sql)))( អេកូជោគជ័យ"; ) else (បន្ទរ "កំហុស"; ))

នៅក្នុងអក្សរ PHP របស់យើង កូដទូទៅបំផុតដែលដំណើរការសំណើប្រកាស និងបោះពុម្ពអត្ថបទជាក់លាក់នៅលើទំព័រ។ ជាលទ្ធផល AJAX ផ្ញើសំណើទៅស្គ្រីប php ស្គ្រីបដំណើរការវា និងបង្កើតលទ្ធផល AJAX អានលទ្ធផល និងផ្លាស់ប្តូរទំព័រក្នុងពេលវេលាជាក់ស្តែង។

AJAX ផ្ញើសំណើ POST ទៅស្គ្រីបដោយប្រើលេខកូដនេះ៖

$.ajax(( type:"POST", url:"email.php", data:"email="+value, success:function(msg)( if(msg == "valid")( $("#message " .html("អ៊ីមែលនេះអាចប្រើបាន។"); email = value; )else($("#message").html("អ៊ីមែលនេះត្រូវបានយករួចហើយ។"); ) ) ));

ប្រភេទ - ប្រភេទស្នើសុំ POST ឬ GET ។ ក្នុងករណីរបស់យើង POST;
url - អាសយដ្ឋាននៃស្គ្រីបដែលសំណើត្រូវបានផ្ញើ។
ទិន្នន័យ - ទិន្នន័យដែលត្រូវបានបញ្ជូននៅក្នុងការស្នើសុំ;
ជោគជ័យ - អ្វីដែលត្រូវធ្វើជាលទ្ធផលនៃការអនុវត្តសំណើជោគជ័យ។ ក្នុងករណីរបស់យើងមុខងារត្រូវបានគេហៅថា;

នៅក្នុងស្គ្រីបខ្លួនវា វត្តមានរបស់អ៊ីមែលនៅក្នុងមូលដ្ឋានទិន្នន័យត្រូវបានពិនិត្យរាល់ពេលដែលតួអក្សរមួយត្រូវបានបញ្ចូលទៅក្នុងវាលអ៊ីមែល។ នៅក្នុងស្គ្រីប ផ្នែក $("#email").keyup(function()()); ដែលពិនិត្យមើលការចុចគ្រាប់ចុចនៅក្នុងវាលដែលមានលេខសម្គាល់ = "អ៊ីមែល" ។
ដូចដែលអ្នកអាចឃើញ កូដគឺសាមញ្ញណាស់ និងមិនតម្រូវឱ្យមានជំនាញដ៏អស្ចារ្យជាពិសេសដើម្បីយល់ អ្វីគ្រប់យ៉ាងត្រូវបានភ្ជាប់ទៅនឹងដំណើរការព្រឹត្តិការណ៍ keyup() - ការចុចគ្រាប់ចុចចុច () - ការចុចកណ្ដុរលើធាតុមួយ។ នេះត្រូវបានបន្តដោយសំណើ AJAX និងការឆ្លើយតបពីស្គ្រីប។ ដូច្នេះដោយប្រើ php និង ajax អ្នកអាចទទួលបានលទ្ធភាពស្ទើរតែគ្មានដែនកំណត់សម្រាប់ការបង្កើតទំព័រអន្តរកម្ម។
កូដនេះមិនធ្វើពុតជាមានគុណភាពខ្ពស់នោះទេ ប៉ុន្តែប្រសិនបើអ្នកបង្កើតវា បន្ថែមសុពលភាពត្រឹមត្រូវនៅកម្រិតម៉ាស៊ីនភ្ញៀវ និងម៉ាស៊ីនមេ ហើយណែនាំ css នោះវាអាចប្រើក្នុងគម្រោងរបស់អ្នក។
ប្រសិនបើអ្នកមានសំណួរណាមួយ សូមកុំស្ទាក់ស្ទើរក្នុងការសរសេរមតិយោបល់។
ខ្ញុំសូមជូនពរឱ្យអ្នកមានថ្ងៃល្អហើយជួបគ្នាឆាប់ៗ :)

7.4K
នៅក្នុងអត្ថបទនេះ ខ្ញុំនឹងរៀបរាប់អំពីការបង្កើត និងការបញ្ជូនទម្រង់ AJAX ។ បន្ទាប់ពីនេះ យើងអាចពិនិត្យមើលការអនុវត្តចលនាដោយប្រើ animate.css សុពលភាពទិន្នន័យដោយប្រើ JavaScript ។

នៅពេលសរសេរអត្ថបទនេះ Bootstrap 3.3.5 គឺជាកំណែបច្ចុប្បន្ននៃក្របខ័ណ្ឌ។ សម្រាប់អត្ថបទនេះ យើងកំពុងប្រើ default Bootstrap build (12 columns)។ នៅពេលអ្នកបញ្ចប់កិច្ចការក្នុងអត្ថបទនេះ ត្រូវប្រាកដថាប្រើកំណាត់ចុងក្រោយ និងរចនាសម្ព័ន្ធកូដដែលបានពិពណ៌នានៅក្នុងឯកសារ Bootstrap ។

រចនាសម្ព័ន្ធឯកសារនិងថត

យើង​នឹង​បង្កើត​ថត root ហើយ​បន្ថែម​ឯកសារ និង​ថត​ខាងក្រោម​ទៅ​វា៖

ទម្រង់ Bootstrap៖

យើងនឹងត្រូវការភ្ជាប់បណ្ណាល័យខាងមុខមួយចំនួន៖

• Bootstrap;
• jQuery ។

ដោយពិចារណាលើបណ្ណាល័យទាំងនេះ រចនាសម្ព័ន្ធឯកសារនឹងមើលទៅដូចនេះ៖

ទម្រង់ Bootstrap៖

ការបង្កើតទម្រង់

បើកឯកសារ index.html របស់អ្នក ហើយចម្លងរចនាសម្ព័ន្ធទម្រង់ទំនាក់ទំនង AJAX មូលដ្ឋានខាងក្រោមទៅក្នុងវា៖

ទម្រង់ទំនាក់ទំនងដោយប្រើ Bootstrap 3.3.4 " ផ្ញើសារមកខ្ញុំ

នេះគឺជាគំរូ HTML មូលដ្ឋានដែលយើងនឹងបន្ថែមមាតិកាទម្រង់។ យើងបានរួមបញ្ចូលឯកសារ CSS និង JavaScript ចាំបាច់ទាំងអស់។ ចំណាំថាសម្រាប់ឧទាហរណ៍ពិសេសនេះ យើងមិនត្រូវការ bootstrap.js ទេ។

យើងបានបញ្ចូលស្លាកមេតានៃទិដ្ឋភាពច្រកសម្រាប់សំណួរប្រព័ន្ធផ្សព្វផ្សាយនៅក្នុង Bootstrap ។ JavaScript ត្រូវបានដាក់នៅផ្នែកខាងក្រោមនៃឯកសារ ដូច្នេះកូដចម្បងត្រូវបានដំណើរការជាមុនសិន។

នៅក្នុងស្លាកតួ យើងបានរួមបញ្ចូល div ជាមួយថ្នាក់ col-sm-6 col-sm-offset-3 ។ នេះ​មាន​ន័យ​ថា​នៅ​ខាង​លើ និង​ខាង​លើ​នៃ sm (តូច) viewport យើង​ចង់​បង្ហាញ​ជួរ​ឈរ​ទទឹង 50% (ចំនួន​ជួរ​ឈរ​អតិបរមា 12)។ ថ្នាក់ col-sm-offset-3 កំណត់អុហ្វសិតខាងឆ្វេងទៅ 25% ។

នេះបង្កើតប្លង់ដែលប្រើពាក់កណ្តាលនៃទំហំដែលអាចប្រើបាន ហើយត្រូវបានដាក់កណ្តាលផ្ដេក។ បន្ទាប់ពីនោះយើងរួមបញ្ចូល h3 ហើយបន្ទាប់មកមូលដ្ឋាននៃទម្រង់។ ត្រូវប្រាកដថាអ្នកអនុវត្តលេខសម្គាល់ទៅក្នុងទម្រង់ ដូច្នេះអ្នកអាចភ្ជាប់ទម្រង់បែបបទ AJAX JQuery បញ្ជូនព្រឹត្តិការណ៍ទៅវានៅពេលក្រោយ៖

គ្មានជ័យជំនះទេបើគ្មានការតស៊ូ

ឈ្មោះ អ៊ីមែល ផ្ញើ សារ ផ្ញើ !

ទាំងនេះគឺជាប្រអប់បញ្ចូល និងប៊ូតុងទាំងអស់ដែលអ្នកប្រើប្រាស់នឹងធ្វើអន្តរកម្មជាមួយ។ div ដំបូង​ដែល​បាន​ចាត់​ថ្នាក់​ជួរ​ដេក​គឺ​វាក្យសម្ព័ន្ធ Bootstrap បុរាណ ដែល​តំណាង​ឱ្យ​ការ​ដាក់​ក្រុម​ផ្តេក​នៃ​ធាតុ col ។ ជួរឈរនៅក្នុង Bootstrap បង្កើត padding ឬចន្លោះពណ៌ស។ តាមរយៈការដកពួកវាចេញ អ្នកអាចធានាថាខ្សែនេះសមស្មើៗគ្នាទៅក្នុងធុង។

យើងបានបង្កើតជួរឈរពីរដែលមានថ្នាក់ col-sm-6 (50%) ដែលយើងនឹងប្រើដើម្បីបំបែកផ្នែកខាងលើនៃទម្រង់។ នៅក្នុងជួរទីមួយ col-sm-6 យើងបានបង្កើតស្លាក និងវាលសម្រាប់ឈ្មោះ និងអ៊ីមែល។ ពួកវានីមួយៗមានស្លាកមួយដែលមានគុណលក្ខណៈដែលត្រូវគ្នា ដូច្នេះស្លាកត្រូវបានភ្ជាប់ជាមួយវាលដែលត្រូវគ្នា។

ជួរនីមួយៗនៃជួរឈរទាំងនេះរួមបញ្ចូលក្រុមទម្រង់ដែលដាក់ជាក្រុមស្លាកសញ្ញាដោយបង្កើតបន្ទះតូចមួយនៅខាងក្រោម៖

វាយអក្សរ

Bootstrap អនុញ្ញាតឱ្យអ្នកប្រើថ្នាក់សម្រាប់ H1-H6 ។ ពួកគេជួយអ្នកឱ្យធ្វើរចនាប័ទ្មធាតុក្នុងជួរដោយមិនបន្ថែមវាលបន្ថែម ឬបង្កើតប្លុកធាតុទម្រង់ទំនាក់ទំនង AJAX ទំនើប។ យើងបានប្រើថ្នាក់ H4 ដើម្បីធ្វើរចនាប័ទ្មស្លាក និងធ្វើឱ្យពួកវាធំ។

ថ្នាក់គ្រប់គ្រងទម្រង់ត្រូវបានអនុវត្តចំពោះធាតុបញ្ចូលនីមួយៗ ដូច្នេះវាបំពេញទទឹងទាំងមូលនៃធុង (ទទឹង 100%) ។ ថ្នាក់នេះក៏បន្ថែមរចនាប័ទ្មផ្សេងៗដែលអនុញ្ញាតឱ្យអ្នកបង្កើតធាតុទម្រង់ងាយស្រួលអាន (ទំហំធំ គែមច្បាស់លាស់។ល។)។

បន្ទាប់ពីជួរឈរទាំងនេះ យើងរួមបញ្ចូលតួនៃសារ។ យើង​រុំ​វា​ជា​ក្រុម​ទម្រង់ ហើយ​អនុវត្ត​រចនាប័ទ្ម​ដូចគ្នា​នឹង​ស្លាក និង​វាល​អត្ថបទ។

អំពាវនាវឱ្យធ្វើសកម្មភាព

តោះបង្កើតប៊ូតុងបញ្ជូន។ Bootstrap មានថ្នាក់សម្រាប់ប៊ូតុងផ្សេងៗ និងស្ថានភាពរបស់វា។ យើងបានសម្រេចចិត្តប្រើប៊ូតុង "ជោគជ័យ" (btn-success) ដែលមានពណ៌បៃតងតាមលំនាំដើម។

អ្នកក៏ត្រូវប្រើថ្នាក់មូលដ្ឋាន btn ដើម្បីកំណត់ឡើងវិញនូវប៉ារ៉ាម៉ែត្រមូលដ្ឋានរបស់ប៊ូតុង (ស៊ុម ទ្រនាប់ តម្រឹមអត្ថបទ ទំហំពុម្ពអក្សរ)។ យើងបានប្រើថ្នាក់ btn-lg ដែលបង្កើតប៊ូតុងធំ ហើយបន្ទាប់មកថ្នាក់ទាញស្តាំ ដែលធ្វើឱ្យប៊ូតុងរុំទៅខាងឆ្វេង។

បន្ទាប់ពីប៊ូតុង យើងបានបញ្ចូល div ជាមួយ ID #msgSubmit ហើយបានអនុវត្តថ្នាក់ខាងក្រោម៖ “h3 text-center hidden” ។ ថ្នាក់ h3 ជួយបង្កើតក្បាលធំជាងមុន មជ្ឈមណ្ឌលអត្ថបទកំណត់ការតម្រឹមអត្ថបទទៅកណ្តាល ហើយឈុតលាក់បង្ហាញ៖ គ្មាន និងអាចមើលឃើញ៖ លាក់ :

បន្ថែមមុខងារសម្រាប់បញ្ជូនទិន្នន័យ

យើងបានបង្កើតទម្រង់ Bootstrap JQuery AJAX ជាមូលដ្ឋានប៉ុន្តែវាមិនទាន់ធ្វើអ្វីនៅឡើយទេ។ ជំហានបន្ទាប់របស់យើងគឺបង្កើតមុខងារដែលយក User input ហើយផ្ញើវា asynchronously ទៅកាន់ PHP។

បើកឯកសារ scripts.js ហើយចម្លងកូដខាងក្រោមទៅក្នុងវា៖

$("#contactForm").submit(function(event)( // cancels submission of form data event.preventDefault(); submitForm(); ));

នេះគឺជាបំណែកនៃកូដ JQuery ដែលស្តាប់មុខងារបញ្ជូនទិន្នន័យ #contactForm (ដូចដែលបានបញ្ជាក់ពីមុន)។ មុនពេលអនុគមន៍នេះ យើងដោះស្រាយអថេរព្រឹត្តិការណ៍ ដែលរក្សាទុកសកម្មភាពនៃការបញ្ជូនទម្រង់សម្រាប់អនុគមន៍។

event.preventDeafult() បញ្ឈប់​ទិន្នន័យ​ទម្រង់​មិន​ត្រូវ​បាន​ដាក់​ស្នើ​នៅ​ពេល​ដែល​ទំព័រ​ត្រូវ​បាន​ធ្វើ​ឱ្យ​ស្រស់​ដោយ​មិន​ជ្រើសរើស​សកម្មភាព​លើ​ទម្រង់​បែបបទ។ ហើយនៅចុងបញ្ចប់លេខកូដនេះស្នើសុំមុខងារ submitForm(); :

អនុគមន៍ submitForm())( // ចាប់ផ្តើមអថេរជាមួយនឹងមាតិកានៃទម្រង់ var name = $("#name").val(); var email = $("#email").val(); var message = $("#message ").val(); $.ajax((ប្រភេទ៖ "POST", url: "php/form-process.php", data: "name=" + name + "&email=" + email + "&message=" + message, success: function(text)( if (text == "success")( formSuccess(); ))) function formSuccess())( $("#msgSubmit").removeClass("hidden ");)

អថេរ​ទាំង​បី​ដែល​បាន​ហៅ​នោះ​ចាប់​យក​តម្លៃ​នៃ​វាល​បញ្ចូល​ទម្រង់​នីមួយៗ ហើយ​បញ្ជូន​វា​ទៅ​អថេរ JavaScript សម្រាប់​ប្រើ​ពេល​ក្រោយ។

យើងចាប់ផ្តើមវត្ថុ AJAX នៅខាងក្នុង JQuery ហើយកំណត់ប៉ារ៉ាម៉ែត្រសម្រាប់ការបង្ហោះ ទីតាំងនៃឯកសារ PHP ទិន្នន័យដែលយើងចង់បង្ហោះ និងមុខងារហៅត្រឡប់មកវិញ។ ទិន្នន័យរួមបញ្ចូលអថេរទាំងបីដែលមានលេខសម្គាល់ដែលត្រូវគ្នា។ មុខងារហៅត្រឡប់មកវិញត្រូវបានហៅនៅពេលដែលវត្ថុ AJAX បានទទួលព័ត៌មានដោយជោគជ័យពីស្គ្រីប PHP ។ មុខងារចាប់យកអត្ថបទដែលបានត្រឡប់មកវិញហើយពិនិត្យមើលថាតើវាស្មើនឹងខ្សែអក្សរ "ជោគជ័យ" ដែរឬទេ។ ប្រសិនបើបាទ/ចាស នោះមុខងារចុងក្រោយរបស់ formSuccess ត្រូវបានដំណើរការ។

វាដកថ្នាក់ដែលលាក់ចេញពី #msgSubmit DIV ដែលយើងបានអនុវត្តមុននេះ ដូច្នេះវាចេញអត្ថបទ។

ការភ្ជាប់ទៅមុខងារ PHP Mail

ឥឡូវអ្នកត្រូវសរសេរស្គ្រីបដែលនឹងទទួលទិន្នន័យពីទម្រង់ AJAX ហើយផ្ញើខ្លឹមសារតាមរយៈមុខងារ PHP Mail ។ បើកឯកសារ process.php ហើយបន្ថែមកូដខាងក្រោមទៅវា៖

យើងត្រូវរក្សាទុកអថេរដែលយើងចង់ប្រើ។ ពីមុខងារសំបុត្រ អ្នកអាចទទួលបានអថេរបញ្ចូលបី ហើយផ្តល់ឱ្យពួកគេនូវឈ្មោះដូចគ្នានៅក្នុង PHP ។ អថេរ $EmailTo គឺជាអាសយដ្ឋានអ៊ីមែលដែលអាចកំណត់ក្នុងស្គ្រីប។ $Subject គឺជាខ្សែអក្សរដែលពិពណ៌នាអំពីប្រធានបទនៃអ៊ីមែល។

តួនៃអក្សរត្រូវបានបង្កើតដោយចៃដន្យជាមួយនឹងការបន្ថែមនៃអថេរដែលបានបង្កើតចំនួនបី។ ដំបូង​យើង​កំណត់​អត្ថបទ​ពណ៌នា​ឧទាហរណ៍ "Name:" បន្ទាប់​មក​មក​អថេរ និង​បន្ទាប់​មក​បន្ទាត់​ថ្មី (/n)។ យើងធ្វើជំហានដូចគ្នាម្តងទៀត ដោយភ្ជាប់ទិន្នន័យទាំងអស់ទៅនឹងអថេរ $body។

ដើម្បីផ្ញើអ៊ីមែល យើងភ្ជាប់វាទៅមុខងារសំបុត្រ។ ដោយកំណត់តម្លៃទៅអថេរ $success យើងបញ្ជាក់អាសយដ្ឋានអ៊ីមែលដែលអ៊ីមែលនឹងត្រូវបានផ្ញើ ប្រធានបទនៃអ៊ីមែល តួអត្ថបទ និងអាសយដ្ឋានអ៊ីមែលរបស់អ្នកផ្ញើ។

ដើម្បីចាប់ផ្តើមដំណើរការផ្ញើអ៊ីមែល អ្នកត្រូវហៅវាទៅក្នុង if statement។ វិធីនេះអ្នកអាចពិនិត្យមើលថាតើទិន្នន័យទម្រង់ត្រូវបានបញ្ជូនដោយជោគជ័យឬអត់។ ប្រសិនបើមុខងារ Mail ត្រឡប់ “ពិត” នោះស្គ្រីបនឹងត្រឡប់ “ជោគជ័យ” ប្រសិនបើមុខងារបោះចោលកំហុស “មិនត្រឹមត្រូវ” នឹងត្រលប់មកវិញ។

លទ្ធផលនេះនឹងត្រូវបានត្រលប់ទៅវត្ថុ AJAX ហើយដំណើរការនៅផ្នែកអតិថិជន។ អត្ថប្រយោជន៍របស់ AJAX គឺថាវាត្រូវបានធ្វើដោយអសមកាលនៅលើផ្នែកអតិថិជន។ វាអនុញ្ញាតឱ្យអ្នកប្រើបន្តធ្វើអន្តរកម្មជាមួយគេហទំព័រខណៈពេលដែលទម្រង់ AJAX កំពុងបញ្ជូនទិន្នន័យ៖

តោះចាំងពន្លឺ

ឥឡូវនេះយើងនឹងផ្តោតលើការផ្តល់មតិកែលម្អរបស់អ្នកប្រើប្រាស់តាមរយៈមុខងារបន្ថែមផ្សេងៗដែលអាចបើកដំណើរការបាន។ ជាពិសេស យើងនឹងពិនិត្យមើលមតិកែលម្អទម្រង់ដោយប្រើការដោះស្រាយកំហុស ទាំងផ្នែកខាងអតិថិជន និងផ្នែកខាងម៉ាស៊ីនមេ។

យើងក៏ប្រើឧបករណ៍មួយចំនួនដើម្បីបញ្ជាក់ទម្រង់បែបបទ៖

• Animate.css: ;
• កម្មវិធីកំណត់សុពលភាព Bootstrap ។

បន្ថែមពួកវាទៅក្នុងគម្រោងរបស់អ្នកដូចដែលយើងបានធ្វើពីមុនជាមួយ Bootstrap និង JQuery។ ឧបករណ៍ទាំងនេះនឹងជួយផ្តល់មតិកែលម្អដល់អ្នកប្រើប្រាស់ បន្ទាប់ពីគាត់បានបញ្ជូនទិន្នន័យ។

រចនាសម្ព័ន្ធគម្រោងឥឡូវនេះគួរតែមើលទៅដូចនេះ:

សុពលភាពទម្រង់

ចូរចាប់ផ្តើមដោយការដំឡើង validator បន្ទាប់ពីបញ្ចូលទិន្នន័យទម្រង់ទំនាក់ទំនង AJAX PHP ។ ចូលទៅកាន់ឯកសារ scripts.js ហើយកែសម្រួលផ្នែកដំបូងនៃកូដដែលហៅមុខងារ SubmitForm() បន្ទាប់ពីទិន្នន័យទម្រង់ត្រូវបានដាក់ស្នើ។
វាត្រូវតែផ្លាស់ប្តូរដូចខាងក្រោមៈ

$("#contactForm").validator().on("submit", function (event) ( if (event.isDefaultPrevented()) ( // handle form error... ) else ( // អ្វីៗគឺល្អ! event .preventDefault(); submitForm();

អត្ថបទកូដថ្មីនេះពិនិត្យមើលថាតើ Bootstrap Validator បានរកឃើញបញ្ហា និងបញ្ឈប់កូដមិនឱ្យដំណើរការដែរឬទេ។ បើមិនអញ្ចឹងទេ យើងបន្តដូចធម្មតា។ យើងនៅតែត្រូវដកសកម្មភាពលំនាំដើម (ផ្ទុកទំព័រឡើងវិញដោយមិនបំពេញទម្រង់) ពីស្គ្រីបនៃការបញ្ជូនទិន្នន័យទម្រង់។

ឥឡូវនេះ ប្រសិនបើ​យើង​ចុច​ប៊ូតុង​ដាក់​ស្នើ​ដោយ​មិន​បាន​បំពេញ​គ្រប់​វាល​ទាំងអស់ នោះ​ទទេ​នឹង​ត្រូវ​បាន​បន្លិច​ជា​ពណ៌​ក្រហម៖

នៅក្នុងដំណើរការនៃការបន្ថែមសុពលភាព យើងបានបិទសុពលភាព HTML5 ដើម។ អ្នក​អាច​បន្ថែម​បរិបទ​បន្ថែម​ទៅ​ក្នុង​ការ​បញ្ជាក់​ដោយ​រួម​បញ្ចូល​ទាំង​សារ​កំហុស។ Bootstrap Validator មានមុខងារងាយស្រួលដែលអនុញ្ញាតឱ្យអ្នកបង្ហាញសារកំហុសសម្រាប់វាលនីមួយៗ។ ដើម្បីបន្ថែមពួកវា អ្នកត្រូវបំពេញការសម្គាល់ HTML ។

នៅខាងក្នុងក្រុមទម្រង់នីមួយៗ នៅក្រោមវាលបញ្ចូលទិន្នន័យ អ្នកត្រូវដាក់កូដ HTML ខាងក្រោម៖

ជាឧទាហរណ៍ ខាងក្រោមនេះគឺជា div បន្ថែមមួយដែលត្រូវបានបន្ថែមទៅក្នុងវាលឈ្មោះ និងអ៊ីមែល៖

ឈ្មោះអ៊ីមែល

ឥឡូវនេះ នៅពេលបញ្ជូនទិន្នន័យទម្រង់ AJAX JQuery សារឡើងវិញ សារកំហុសនឹងត្រូវបានបង្ហាញ ប្រសិនបើប្រអប់ទម្រង់មិនត្រូវបានបំពេញ៖ “សូមបំពេញក្នុងវាលនេះ។ " ដោយបន្ថែមគុណលក្ខណៈទិន្នន័យទៅទិន្នន័យបញ្ចូលដែលហៅថា "កំហុសទិន្នន័យ" អ្នកអាចបញ្ចូលសារកំហុសផ្ទាល់ខ្លួន។

ឧទាហរណ៍:

ការបន្ថែមមតិកែលម្អចលនា

យើងបានបន្ថែមមុខងារដើម្បីចង្អុលបង្ហាញវាលទម្រង់ទទេ។ ប៉ុន្តែវាជាការប្រសើរណាស់ក្នុងការបន្ថែមចលនាបន្ថែមមួយចំនួនទៅក្នុងទម្រង់ និងសារមួយចំនួនដើម្បីឱ្យអ្នកប្រើប្រាស់ដឹងពីអ្វីដែលកំពុងកើតឡើង។ បច្ចុប្បន្ននេះ នៅពេលដែលទិន្នន័យទម្រង់ត្រូវបានដាក់ជូនដោយជោគជ័យ សារ “Message Submitted! "ប៉ុន្តែចុះយ៉ាងណាចំពោះកំហុស?

ដើម្បីប្រើលេខកូដដែលមានស្រាប់ យើងនឹងកែប្រែសារជោគជ័យនៃការបញ្ជូនទិន្នន័យដែលមានស្រាប់។ ជាដំបូង យើងលុបអត្ថបទ “Message Submitted! " ពី HTML markup ហើយទុក div ឱ្យនៅទទេ៖

ឥឡូវនេះយើងត្រូវបង្កើតមុខងារថ្មីមួយដើម្បីគ្រប់គ្រងស្ថានភាពសារ។ បន្ថែមមុខងារនេះទៅផ្នែកខាងក្រោមនៃឯកសារ scripts.js របស់អ្នក៖

អនុគមន៍ submitMSG(valid, msg)( var msgClasses; if(valid)( msgClasses = "h3 text-center tada animated text-success"; ) else (msgClasses = "h3 text-center text-danger"; ) $("# msgSubmit").removeClass().addClass(msgClasses).text(msg); )

មុខងារនេះយកអាគុយម៉ង់ពីរ។ សុពលភាពនឹងជាអថេរប៊ូលីន៖ ប្រសិនបើតម្លៃរបស់វាពិត សារមួយនឹងត្រូវបានបង្ហាញដែលបង្ហាញថាទិន្នន័យត្រូវបានផ្ញើដោយជោគជ័យ។ ប្រសិនបើមិនពិត សារកំហុសនឹងត្រូវបានបោះពុម្ព។ msg គឺជាសារដែលយើងនឹងបង្ហាញនៅក្នុងប្លុក div ។

មុខងារនេះពិនិត្យមើលថាតើយើងកំពុងដោះស្រាយជាមួយសារអំពីការបញ្ជូនទិន្នន័យដោយជោគជ័យ ឬសារកំហុស។ នេះត្រូវបានធ្វើដោយពិនិត្យមើលតម្លៃនៃអថេរដែលមានសុពលភាព។ វិធីណាក៏ដោយ វាកំណត់អថេរជាមួយនឹងថ្នាក់ CSS ដែលសមស្រប (យើងត្រូវបញ្ចូល h3 និងមជ្ឈមណ្ឌលអត្ថបទឡើងវិញ ព្រោះយើងនឹងលុបវាចេញ)។

ចំណាំ៖ សម្រាប់ថ្នាក់សារជោគជ័យ យើងកំពុងប្រើថ្នាក់ animate.css មួយចំនួន។ នៅពេលដែលទិន្នន័យទម្រង់ទំនាក់ទំនង AJAX JQuery ត្រូវបានបញ្ជូនដោយជោគជ័យ ចលនា tada នឹងលេង។

ជាចុងក្រោយ មុខងារដកថ្នាក់ទាំងអស់ចេញពី #msgSubmit (ដើម្បីជៀសវាងការជាន់គ្នាថ្នាក់) ហើយបន្ទាប់មកកំណត់ថ្នាក់អាទិភាព និងបន្ថែមអត្ថបទសារទៅ div ។

នៅខាងក្នុង validator initialization នៅដើមផ្នែកនេះ យើងធ្វើបច្ចុប្បន្នភាពកូដដើម្បីបន្ថែមការហៅទៅកាន់មុខងារខាងក្រោមនៅខាងក្នុង if statement នៅពេលវាវាយតម្លៃទៅ true៖

submitMSG(មិនពិត "តើអ្នកបានបំពេញទម្រង់បែបបទត្រឹមត្រូវទេ?");

ឥឡូវនេះ ប្រសិនបើអ្នកមិនបំពេញគ្រប់វាលទាំងអស់ទេ អ្នកនឹងទទួលបានសារកំហុសមួយ “តើអ្នកបានបំពេញទម្រង់បែបបទត្រឹមត្រូវទេ? »

ជំហានចុងក្រោយសម្រាប់មុខងារ submitMSG ថ្មីនេះគឺត្រូវហៅវានៅពេលដែលទិន្នន័យទម្រង់ត្រូវបានដាក់ស្នើដោយជោគជ័យ។ ធ្វើបច្ចុប្បន្នភាពមុខងារ formSuccess() ដូចខាងក្រោម៖

$("#contactForm").កំណត់ឡើងវិញ(); submitMSG(ពិត "បានបញ្ជូនសារ!")

យើងចង់កំណត់ទម្រង់ឡើងវិញ និងជម្រះតម្លៃនៅពេលយើងហៅមុខងារ submitMSG ដូចមានចែងខាងលើជាមួយនឹងសារបញ្ជូនជោគជ័យ។ ឥឡូវនេះ នៅពេលដែលទិន្នន័យទម្រង់ត្រូវបានបញ្ជូនដោយជោគជ័យ សារដែលត្រូវគ្នាជាមួយ animate.css tada animation គួរតែត្រូវបានបង្ហាញ៖

ចូរ​អង្រួន​ខ្លួន​យើង​ឡើង

តោះ​បន្ថែម​ចលនា​កំហុស​ទៅ​ក្នុង​ទម្រង់​ទាំងមូល ចលនា "ញ័រ" ទូទៅ​គួរតែ​ធ្វើ​ល្បិច!

បង្កើតមុខងារថ្មីភ្លាមៗបន្ទាប់ពី formSuccess() ហើយហៅវាថា formError():

function formError())( $("#contactForm").removeClass().addClass("shake animated").one("webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend", function())( $(this).removeClass(); )) ;

មុខងារនេះប្រើវិធីសាស្រ្តដែលបានពិពណ៌នានៅក្នុងទំព័រសាកល្បង animate.css ដែលអនុញ្ញាតឱ្យអ្នកបន្ថែមចលនាទៅធាតុមួយ ហើយបន្ទាប់មកហៅវាម្តងទៀត។

គំនូរជីវចល CSS មានមុខងារអកុសល៖ វាមិនអាចចាក់ឡើងវិញបានទេ ទោះបីជាថ្នាក់ត្រូវបានដកចេញ និងបន្ថែមឡើងវិញក៏ដោយ។ មុខងារនេះជួយកំណត់ថ្នាក់បញ្ចប់នៃចលនាឡើងវិញ ដូច្នេះអ្នកអាចបញ្ចូលវាឡើងវិញបាន។ នៅពេលដែលអ្នកប្រើប្រាស់ចុចប៊ូតុង "ដាក់ស្នើ" ដោយមិនបំពេញគ្រប់វាលទាំងអស់នៃទម្រង់មតិត្រឡប់ AJAX យើងលេងចលនាញ័រ។ ហើយប្រសិនបើវាមិនបំពេញគ្រប់វាលម្តងទៀតទេ អ្នកត្រូវលេងចលនានេះម្តងទៀត។

អ្នកអាចហៅមុខងារ formError() ខាងលើមុខងារ submitMSG() ដែលយើងបានបង្កើតដើម្បីរាយការណ៍អំពីកំហុស។ ឧទាហរណ៍ដូចនេះ៖

formError(); submitMSG(មិនពិត "តើអ្នកបានបំពេញទម្រង់បែបបទត្រឹមត្រូវទេ?");

ឥឡូវនេះ នៅពេលដែលអ្នកប្រើប្រាស់ព្យាយាមបញ្ជូនទិន្នន័យទម្រង់ដោយមិនបំពេញគ្រប់វាលទាំងអស់ វានឹងញ័រដើម្បីឱ្យគាត់ដឹងថាមានអ្វីមួយខុស។

សុពលភាពបន្ថែមទៀត

សុពលភាពផ្នែកអតិថិជនគឺល្អ ប៉ុន្តែអ្នកប្រើប្រាស់ណាម្នាក់អាចបិទវា ហើយដាក់ទម្រង់ជាមួយវាលទទេដោយកែសម្រួលកូដនៅក្នុងកម្មវិធីរុករក។ វាចាំបាច់ក្នុងការបង្កើតសេវាកម្មផ្ទៀងផ្ទាត់នៅលើផ្នែកម៉ាស៊ីនមេ។

យើងត្រូវបើកឯកសារ process.php ហើយធ្វើការផ្លាស់ប្តូរចាំបាច់ដើម្បីធានាថាគ្រប់វាលទាំងអស់ត្រូវបានធីក។ យើងនឹងបង្កើតអថេរ $errorMSG ដើម្បីចាប់សារកំហុស ហើយបន្ទាប់មកបើកការត្រួតពិនិត្យ $_POST បន្ថែម៖

កូដ PHP នេះពិនិត្យមើលថាតើវាលទម្រង់ AJAX ទទេមានឬអត់ មុនពេលកំណត់ទិន្នន័យរបស់ពួកគេជាអថេរដែលត្រូវគ្នា (ជំនួសអថេរដែលបានកំណត់កូដដែលមានស្រាប់ពី $_POST )។ ប្រសិនបើវាលទទេ យើងបញ្ជាក់សារទូទៅដើម្បីផ្ញើត្រឡប់ទៅអតិថិជនវិញ។

ដើម្បីឆ្លើយតបទៅនឹងការហៅទូរស័ព្ទ AJAX ដើម យើងត្រូវផ្ញើសារកំហុសដែលនឹងត្រូវបានបង្ហាញនៅក្នុងកម្មវិធីរុករក។ ដើម្បីធ្វើដូច្នេះ សូមកែសម្រួល if statement ដែលយើងបានបង្កើតមុននៅខាងក្រោមនៃកូដ PHP៖

តាមរយៈ if statement យើងពិនិត្យមើលថាតើអថេរ $errorMSG គឺទទេ (“”) ក៏ដូចជាស្ថានភាពនៃមុខងារ Mail ដែលភ្ជាប់មកជាមួយដែលយើងបានប្រើសម្រាប់អថេរ $success variable។ នៅក្នុងលក្ខខណ្ឌផ្សេងទៀត យើងបានរួមបញ្ចូលការត្រួតពិនិត្យបន្ថែម ដើម្បីមើលថាតើកំហុសគឺជាលទ្ធផលនៃការបរាជ័យ $success ដែរឬទេ។ ប្រសិនបើបាទ/ចាស យើងផ្ញើសារវិញថា "មានអ្វីមួយខុសប្រក្រតី៖"។ បើមិនដូច្នេះទេ យើងបង្ហាញសារដែលត្រូវបានចងក្រងនៅពេលយើងពិនិត្យរកវាលទទេ។

ហើយជំហានចុងក្រោយគឺត្រូវទទួលយកសារថ្មីនៅក្នុង AJAX ហើយបង្ហាញវាក្នុងទម្រង់។ យើងត្រូវធ្វើបច្ចុប្បន្នភាពវត្ថុ AJAX នៅក្នុងឯកសារ scripts.js ដូចនេះ៖

$.ajax(( type: "POST", url: "php/form-process.php", data: "name=" + name + "&email=" + email + "&message=" + message, success: function( text)(ប្រសិនបើ (អត្ថបទ == "ជោគជ័យ")( formSuccess(); ) else ( formError(); submitMSG(false,text); ) ) ));

យើងទើបតែបានធ្វើបច្ចុប្បន្នភាពលក្ខខណ្ឌផ្សេងទៀត ដែលពិនិត្យមើលអត្ថបទ == ជោគជ័យ។ នៅក្នុងមុខងារផ្សេងទៀត យើងហៅមុខងារ formError() ដែលអនុវត្តចលនាញ័រ ហើយសួរមុខងារ submitMSG() សម្រាប់អត្ថបទដែលត្រឡប់ពី PHP ។

សេចក្តីសន្និដ្ឋាន

ទៅកាន់ Github ដើម្បីមើលកូដទាំងមូល។ ឥឡូវនេះទម្រង់បែបបទមតិត្រឡប់ AJAX PHP ផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវព័ត៌មានអំពីកន្លែងដែលគាត់មិនបានបំពេញ។ យើងបញ្ចេញសារបរិបទដោយផ្អែកលើស្ថានភាព និងសារត្រឡប់ពី PHP ។ យើងក៏បានអនុវត្តកម្រិតបន្ថែមនៃការផ្ទៀងផ្ទាត់ផ្នែកខាងម៉ាស៊ីនមេសម្រាប់អ្នកប្រើប្រាស់ទាំងនោះដែលព្យាយាមឆ្លងកាត់ការផ្ទៀងផ្ទាត់ផ្នែកខាងមុខ។

ខ្ញុំសង្ឃឹមថាអ្នកចូលចិត្តអត្ថបទនេះ។ សូមទុកសំណួរ និងមតិកែលម្អរបស់អ្នកនៅក្នុងមតិយោបល់។

ការបោះពុម្ភផ្សាយនេះគឺជាការបកប្រែនៃអត្ថបទ "ការកសាងទម្រង់ទំនាក់ទំនង Bootstrap ដោយប្រើ PHP និង AJAX" ដែលរៀបចំដោយក្រុមគម្រោងមិត្តភាព

នៅក្នុងបញ្ជីនៃប្រភេទការវាយប្រហារទូទៅបំផុតទាំង 10 យោងទៅតាម OWASP កន្លែងពីរដំបូងត្រូវបានកាន់កាប់ដោយការបញ្ចូលកូដ និងការវាយប្រហារ XSS (ឆ្លងកាត់គេហទំព័រ) ។ ពួកគេដើរទន្ទឹមគ្នា ពីព្រោះ XSS ដូចជាការវាយប្រហារជាច្រើនប្រភេទផ្សេងទៀត អាស្រ័យលើភាពជោគជ័យនៃការវាយប្រហារដោយការចាក់។ ឈ្មោះនេះលាក់នូវប្រភេទការវាយប្រហារទាំងមូល ដែលទិន្នន័យត្រូវបានបញ្ចូលទៅក្នុងកម្មវិធីបណ្តាញ ដើម្បីបង្ខំវាឱ្យប្រតិបត្តិ ឬបកស្រាយកូដព្យាបាទតាមរបៀបដែលអ្នកវាយប្រហារចង់បាន។ ការវាយប្រហារទាំងនេះរួមមានដូចជា XSS, SQL injection, header injection, code injection, និង Full Path Disclosure ។ ហើយនេះគ្រាន់តែជាផ្នែកតូចមួយប៉ុណ្ណោះ។

ការវាយប្រហារដោយការចាក់គឺជារឿងដ៏រន្ធត់សម្រាប់អ្នកសរសេរកម្មវិធីទាំងអស់។ ពួកវាជារឿងធម្មតាបំផុត និងជោគជ័យដោយសារតែភាពខុសគ្នា មាត្រដ្ឋាន និង (ជួនកាល) ការលំបាកក្នុងការការពារប្រឆាំងនឹងពួកគេ។ កម្មវិធីទាំងអស់ត្រូវទទួលបានទិន្នន័យពីកន្លែងណាមួយ។ XSS និង UI Redress គឺជារឿងធម្មតាជាពិសេស ដូច្នេះខ្ញុំបានលះបង់ជំពូកដាច់ដោយឡែកសម្រាប់ពួកគេ ហើយបំបែកពួកគេចេញពីថ្នាក់ទូទៅ។

OWASP ផ្តល់និយមន័យដូចខាងក្រោមនៃការវាយប្រហារដោយការចាក់៖

ឱកាសចាក់បញ្ចូល - ដូចជា SQL, OS និង LDAP - កើតឡើងនៅពេលដែលអ្នកបកប្រែទទួលបានទិន្នន័យដែលមិនគួរឱ្យទុកចិត្តជាផ្នែកនៃសំណើពាក្យបញ្ជា។ ទិន្នន័យព្យាបាទអាចបញ្ឆោតអ្នកបកប្រែឱ្យប្រតិបត្តិពាក្យបញ្ជាជាក់លាក់ ឬចូលប្រើទិន្នន័យដែលគ្មានការអនុញ្ញាត។

ការចាក់ SQL

ការចាក់ SQL គឺជាទម្រង់ទូទៅ និងគ្រោះថ្នាក់បំផុតនៃការវាយប្រហារដោយការចាក់។ វាពិបាកក្នុងការវាយតម្លៃលើសកម្រិតនៃភាពធ្ងន់ធ្ងរនៃការគំរាមកំហែងនេះ ដូច្នេះវាមានសារៈសំខាន់ខ្លាំងណាស់ក្នុងការយល់ដឹងអំពីអ្វីដែលមានឥទ្ធិពលលើភាពជោគជ័យនៃការវាយប្រហារ និងរបៀបការពារប្រឆាំងនឹងពួកគេ។

ដូច្នេះ ទិន្នន័យ​ត្រូវ​បាន​បញ្ចូល​ទៅ​ក្នុង​កម្មវិធី​បណ្ដាញ ហើយ​បន្ទាប់​មក​ប្រើ​ក្នុង​សំណួរ SQL ។ ពួកវាជាធម្មតាបានមកពីប្រភពបញ្ចូលដែលមិនគួរឱ្យទុកចិត្ត ដូចជាទម្រង់គេហទំព័រជាដើម។ ទោះយ៉ាងណាក៏ដោយ ការចាក់ថ្នាំក៏អាចត្រូវបានធ្វើពីកន្លែងផ្សេងទៀតដែរ និយាយថាមកពីមូលដ្ឋានទិន្នន័យខ្លួនឯង។ អ្នកសរសេរកម្មវិធីតែងតែជឿជាក់លើសុវត្ថិភាពពេញលេញនៃមូលដ្ឋានទិន្នន័យរបស់ពួកគេ ដោយមិនដឹងថាប្រសិនបើវាមានសុវត្ថិភាពក្នុងករណីមួយ វាមិនមានន័យទាល់តែសោះថាវានឹងមានសុវត្ថិភាពនាពេលអនាគត។ ទិន្នន័យពីមូលដ្ឋានទិន្នន័យគួរតែត្រូវបានចាត់ទុកថាមិនគួរឱ្យទុកចិត្តរហូតដល់មានការបញ្ជាក់ផ្សេងពីនេះ ពោលគឺរហូតដល់វាត្រូវបានផ្ទៀងផ្ទាត់។

ប្រសិនបើការវាយប្រហារជោគជ័យ អ្នកវាយប្រហារអាចរៀបចំសំណួរ SQL ដើម្បីឱ្យវាធ្វើប្រតិបត្តិការលើមូលដ្ឋានទិន្នន័យដែលមិនមានបំណងដោយអ្នកអភិវឌ្ឍន៍។

សូមមើលសំណួរនេះ៖

$db = new mysqli("localhost", "username", "password", "storedb"); $result = $db->query("SELECT * FROM transactions WHERE user_id = " . $_POST["user_id"]);

មានការកកស្ទះជាច្រើននៅទីនេះ។ ដំបូង យើងមិនបានពិនិត្យខ្លឹមសារនៃទិន្នន័យ POST ដើម្បីធានាថា user_id ត្រឹមត្រូវ។ ទីពីរ យើងអនុញ្ញាតឱ្យប្រភពដែលមិនគួរឱ្យទុកចិត្តប្រាប់យើងថាតើ user_id មួយណាត្រូវប្រើ៖ អ្នកវាយប្រហារអាចរអិលក្នុង user_id ត្រឹមត្រូវ។ វាប្រហែលជាត្រូវបានផ្ទុកនៅក្នុងវាលលាក់នៅលើទម្រង់ដែលយើងគិតថាមានសុវត្ថិភាព ព្រោះវាមិនអាចកែសម្រួលបាន (ខណៈពេលដែលភ្លេចថាអ្នកវាយប្រហារអាចបញ្ចូលទិន្នន័យដែលពួកគេចង់បាន)។ ទីបី យើងមិនបានគេចចេញពី user_id ហើយមិនបានបញ្ជូនវាទៅសំណើជាប៉ារ៉ាម៉ែត្រចង ដែលអនុញ្ញាតឱ្យអ្នកវាយប្រហារបញ្ចូលខ្សែអក្សរតាមអំពើចិត្តដែលនឹងរៀបចំសំណួរ SQL ដោយហេតុថាយើងមិនអាចពិនិត្យវាតាំងពីដំបូង។ .

ការខកខានទាំងបីនេះគឺជារឿងធម្មតាណាស់នៅក្នុងកម្មវិធីគេហទំព័រ។

ទាក់ទងនឹងការជឿទុកចិត្តលើមូលដ្ឋានទិន្នន័យ សូមស្រមៃថាយើងរកមើលប្រតិបត្តិការដោយប្រើវាល user_name ។ ឈ្មោះមានវិសាលភាពទូលំទូលាយ ហើយអាចមានសញ្ញាសម្រង់។ ចូរនិយាយថាអ្នកវាយប្រហាររក្សាទុកតម្លៃខ្សែអក្សរដែលចាក់បញ្ចូលក្នុងឈ្មោះអ្នកប្រើប្រាស់ណាមួយ។ នៅពេលយើងប្រើតម្លៃនេះម្តងទៀតនៅក្នុងសំណួរមួយក្នុងចំណោមសំណួរខាងក្រោម វានឹងរៀបចំខ្សែអក្សរសំណួរ ចាប់តាំងពីយើងបានចាត់ទុកមូលដ្ឋានទិន្នន័យជាប្រភពដែលអាចទុកចិត្តបាន ហើយមិនបានញែកដាច់ពីគ្នា ឬកំណត់សំណួរដែលត្រូវបានសម្របសម្រួលនោះទេ។

យកចិត្តទុកដាក់ផងដែរចំពោះកត្តាមួយផ្សេងទៀតនៅក្នុងការអនុវត្ត SQL៖ ការផ្ទុកជាប់លាប់មិនតែងតែត្រូវរក្សាទុកនៅលើម៉ាស៊ីនមេនោះទេ។ HTML 5 គាំទ្រការប្រើប្រាស់មូលដ្ឋានទិន្នន័យផ្នែកខាងអតិថិជន ដែលអ្នកអាចផ្ញើសំណួរដោយប្រើ SQL និង JavaScript ។ មាន APIs ពីរសម្រាប់នេះ៖ WebSQL និង IndexedDB ។ ក្នុងឆ្នាំ 2010 W3C មិនបានផ្តល់អនុសាសន៍ឱ្យជ្រើសរើស WebSQL ទេ។ វាត្រូវបានគាំទ្រដោយកម្មវិធីរុករក WebKit ដោយប្រើ SQLite ជាកម្មវិធីខាងក្រោយ។ ភាគច្រើនទំនងជាការគាំទ្រនឹងនៅតែមានសម្រាប់ជាប្រយោជន៍នៃភាពឆបគ្នាថយក្រោយ ទោះបីជាមានការណែនាំ W3C ក៏ដោយ។ ដូចដែលឈ្មោះរបស់វាបានបង្ហាញ API នេះទទួលយកសំណួរ SQL ដែលមានន័យថាវាអាចជាគោលដៅសម្រាប់ការវាយប្រហារដោយការចាក់។ IndexedDB គឺជាជម្រើសថ្មីជាងនេះ មូលដ្ឋានទិន្នន័យ NoSQL (មិនតម្រូវឱ្យមានការប្រើប្រាស់ SQL queries)។

ឧទាហរណ៍នៃការចាក់ SQL

រៀបចំសំណួរ SQL អាចបម្រើគោលបំណងដូចខាងក្រោមៈ

ការលេចធ្លាយទិន្នន័យ។

ការបង្ហាញព័ត៌មានដែលបានរក្សាទុក។

ការរៀបចំព័ត៌មានដែលបានរក្សាទុក។

ឆ្លងកាត់ការអនុញ្ញាត។

ការចាក់ SQL ខាងអតិថិជន។

ការការពារការចាក់ SQL

ការការពារប្រឆាំងនឹងការចាក់ SQL គឺផ្អែកលើគោលការណ៍នៃ echeloning ។ មុនពេលប្រើទិន្នន័យក្នុងសំណួរ អ្នកត្រូវតែពិនិត្យមើលថាទម្រង់របស់វាត្រឹមត្រូវ។ វាក៏ចាំបាច់ផងដែរក្នុងការញែកទិន្នន័យមុនពេលបញ្ចូលវាទៅក្នុងសំណើ ឬបញ្ចូលវាជាប៉ារ៉ាម៉ែត្រនៃការផ្លាស់ប្តូរ។

ការប្រឡង

ខ្ញុំបន្តធ្វើវាឡើងវិញ៖ ទិន្នន័យទាំងអស់ដែលមិនត្រូវបានបង្កើតយ៉ាងច្បាស់នៅក្នុងកូដប្រភព PHP នៃសំណើបច្ចុប្បន្នគឺមិនអាចទុកចិត្តបាន។ ពិនិត្យពួកវាយ៉ាងតឹងរ៉ឹង ហើយបដិសេធរាល់អ្វីដែលមិនឆ្លងកាត់ការត្រួតពិនិត្យ។ កុំព្យាយាម "កែតម្រូវ" ទិន្នន័យតែប៉ុណ្ណោះ ការផ្លាស់ប្តូរកែសម្ផស្សចំពោះទម្រង់អាចត្រូវបានធ្វើឡើង។

កំហុសទូទៅរួមមានការធ្វើឱ្យទិន្នន័យមានសុពលភាពសម្រាប់ការប្រើប្រាស់បន្ត (ដូចជាការបង្ហាញ ឬការគណនា) និងការមិនធ្វើឱ្យមានសុពលភាពក្នុងវាលទិន្នន័យដែលព័ត៌មាននឹងត្រូវបានរក្សាទុកជាលទ្ធផល។

ការការពារ

ដោយប្រើផ្នែកបន្ថែម mysqli អ្នកអាចញែកទិន្នន័យទាំងអស់ដែលមាននៅក្នុងសំណួរ SQL ។ មុខងារ mysqli_real_escape_string() ធ្វើដូចនេះ។ ផ្នែកបន្ថែម pgsql សម្រាប់ PostgresSQL ផ្តល់នូវមុខងារ pg_escape_bytea() , pg_escape_identifier() , pg_escape_literal() និង pg_escape_string() ។ ផ្នែកបន្ថែម mssql (Microsoft SQL Server) មិនមានមុខងារឯកោទេ ហើយវិធីសាស្រ្ត addslashes() មិនមានប្រសិទ្ធភាពទេ - អ្នកនឹងត្រូវការមុខងារផ្ទាល់ខ្លួន។

ដើម្បីធ្វើឱ្យជីវិតរបស់អ្នកកាន់តែលំបាក ខ្ញុំនឹងនិយាយថា អ្នកគ្មានសិទ្ធិធ្វើខុសទេ នៅពេលញែកទិន្នន័យដែលបានបញ្ចូលទៅក្នុងសំណើ។ នឹកមួយហើយអ្នកងាយរងការវាយប្រហារ។

សង្ខេប។ ការការពារមិនមែនជាជម្រើសល្អបំផុតទេ។ វាគួរតែត្រូវបានប្រើជាមធ្យោបាយចុងក្រោយ។ វាអាចត្រូវការប្រសិនបើបណ្ណាល័យមូលដ្ឋានទិន្នន័យដែលអ្នកប្រើសម្រាប់ការអរូបីអនុញ្ញាតឱ្យអ្នកកំណត់រចនាសម្ព័ន្ធសំណួរ SQL ទទេ ឬផ្នែកនៃសំណួរដោយមិនបង្ខំឱ្យចងប៉ារ៉ាម៉ែត្រ។ ក្នុងករណីផ្សេងទៀត វាជាការប្រសើរក្នុងការជៀសវាងភាពឯកោទាំងអស់គ្នា។ វិធីសាស្រ្តនេះគឺស្មុគ្រស្មាញ ងាយនឹងមានកំហុស និងប្រែប្រួលអាស្រ័យលើផ្នែកបន្ថែមនៃមូលដ្ឋានទិន្នន័យ។

សំណួរដែលកំណត់ប៉ារ៉ាម៉ែត្រ (កន្សោមដែលបានរៀបចំ)

Parameterization ឬការចងប៉ារ៉ាម៉ែត្រគឺជាវិធីដែលបានណែនាំដើម្បីបង្កើតសំណួរ SQL ។ បណ្ណាល័យមូលដ្ឋានទិន្នន័យល្អទាំងអស់ប្រើវាតាមលំនាំដើម។ នេះគឺជាឧទាហរណ៍នៃការប្រើប្រាស់ផ្នែកបន្ថែម PDO សម្រាប់ PHP៖

if(ctype_digit($_POST["id"]) && is_int($_POST["id"])) ( $validatedId = $_POST["id"]; $pdo = new PDO("mysql:store.db") ; $stmt = $pdo->prepare("SELECT * FROM transactions WHERE user_id = :id"); $stmt->bindParam(":id", $validatedId, PDO::PARAM_INT) ផ្សេងទៀត (//បដិសេធ តម្លៃលេខសម្គាល់ និងជូនដំណឹងដល់អ្នកប្រើប្រាស់អំពីកំហុស)

វិធីសាស្រ្ត bindParam() ដែលអាចរកបានសម្រាប់កន្សោម PDO អនុញ្ញាតឱ្យប៉ារ៉ាម៉ែត្រត្រូវបានចងភ្ជាប់ទៅនឹង "កន្លែងដាក់" ដែលផ្តល់នៅក្នុងកន្សោមដែលបានរៀបចំពីមុន។ វិធីសាស្រ្តនេះទទួលយកប៉ារ៉ាម៉ែត្រនៃប្រភេទទិន្នន័យមូលដ្ឋានដូចជា PDO::PARAM_INT , PDO::PARAM_BOOL , PDO::PARAM_LOB និង PDO::PARAM_STR ។ នេះគឺជាលំនាំដើមសម្រាប់ PDO::PARAM_STR លើកលែងតែមានការបញ្ជាក់ផ្សេង ដូច្នេះសូមចងចាំតម្លៃផ្សេងទៀតផងដែរ!

មិនដូចការឯកោដោយដៃទេ ការចងប៉ារ៉ាម៉ែត្រ (ឬវិធីណាក៏ដោយដែលបណ្ណាល័យមូលដ្ឋានទិន្នន័យរបស់អ្នកប្រើ) នឹងញែកទិន្នន័យដែលបានចងដោយស្វ័យប្រវត្តិយ៉ាងត្រឹមត្រូវ ដូច្នេះអ្នកមិនចាំបាច់ចាំថាមុខងារណាដែលត្រូវប្រើនោះទេ។ ដូចគ្នានេះផងដែរ ការចងប៉ារ៉ាម៉ែត្រជាប់លាប់គឺអាចទុកចិត្តបានច្រើនជាងការព្យាយាមចងចាំថាអ្នកត្រូវញែកអ្វីៗគ្រប់យ៉ាងដោយដៃ។

ការអនុវត្តគោលការណ៍នៃសិទ្ធិតិចតួចបំផុត។

ការបញ្ចប់ការចាក់ SQL ដែលជោគជ័យគឺមានសារៈសំខាន់ដូចគ្នានឹងការការពារវាទាំងស្រុងដែរ។ នៅពេលដែលអ្នកវាយប្រហារទទួលបានសមត្ថភាពក្នុងការប្រតិបត្តិសំណួរ SQL គាត់នឹងធ្វើដូច្នេះក្នុងនាមជាអ្នកប្រើប្រាស់មូលដ្ឋានទិន្នន័យជាក់លាក់។ គោលការណ៍នៃសិទ្ធិតិចតួចបំផុតអាចធានាថាអ្នកប្រើប្រាស់ទាំងអស់មានសិទ្ធិទាំងនោះដែលចាំបាច់បំផុតក្នុងការអនុវត្តភារកិច្ចរបស់ពួកគេ។

ប្រសិនបើអ្នកប្រើមានសិទ្ធិខ្ពស់ អ្នកវាយប្រហារអាចទម្លាក់តារាង និងផ្លាស់ប្តូរសិទ្ធិរបស់អ្នកប្រើប្រាស់ផ្សេងទៀតដោយអនុវត្តការចាក់ SQL ថ្មីជំនួសពួកគេ។ ដើម្បីការពារកុំឱ្យវាកើតឡើង កុំចូលប្រើមូលដ្ឋានទិន្នន័យពីកម្មវិធីបណ្ដាញជា root អ្នកគ្រប់គ្រង ឬអ្នកប្រើប្រាស់ផ្សេងទៀតដែលមានសិទ្ធិខ្ពស់។

ការអនុវត្តគោលការណ៍មួយទៀតគឺការបំបែកតួនាទីនៃការអាន និងការសរសេរទិន្នន័យទៅកាន់មូលដ្ឋានទិន្នន័យ។ ជ្រើសរើស​អ្នក​ប្រើ​ម្នាក់​ដែល​មាន​សិទ្ធិ​តែ​សរសេរ និង​អ្នក​ប្រើ​ម្នាក់​ទៀត​មាន​សិទ្ធិ​តែ​អាន។ ប្រសិនបើការវាយប្រហារសំដៅទៅលើអ្នកប្រើប្រាស់ "ការអាន" នោះអ្នកវាយប្រហារនឹងមិនអាចរៀបចំទិន្នន័យក្នុងតារាង ឬសរសេរវាបានទេ។ អ្នកអាចកំណត់ការចូលប្រើកាន់តែចង្អៀត ដោយកាត់បន្ថយផលប៉ះពាល់នៃការវាយប្រហារដោយជោគជ័យ SQL ។

កម្មវិធីគេហទំព័រជាច្រើន ជាពិសេសប្រភពបើកចំហ ត្រូវបានរចនាឡើងដើម្បីប្រើតែអ្នកប្រើប្រាស់មូលដ្ឋានទិន្នន័យតែមួយប៉ុណ្ណោះ ដែលកម្រិតសិទ្ធិរបស់ពួកគេគឺស្ទើរតែមិនដែលត្រូវបានពិនិត្យ។ ដូច្នេះកុំភ្លេចអំពីចំណុចនេះហើយកុំព្យាយាមដំណើរការកម្មវិធីនៅក្រោមគណនីអ្នកគ្រប់គ្រង។

ការបញ្ចូលលេខកូដ (ត្រូវបានគេស្គាល់ថាជាការដាក់បញ្ចូលឯកសារពីចម្ងាយ)

ការចាក់កូដគឺជាបច្ចេកទេសណាមួយដែលអនុញ្ញាតឱ្យអ្នកវាយប្រហារបន្ថែមកូដប្រភពទៅកម្មវិធីគេហទំព័រដែលមានសមត្ថភាពក្នុងការបកស្រាយ និងប្រតិបត្តិវា។ ក្នុងករណីនេះ យើងមិននិយាយអំពីការណែនាំកូដទៅក្នុងផ្នែកអតិថិជនទេ ឧទាហរណ៍នៅក្នុង JavaScript ការវាយប្រហារ XSS ត្រូវបានប្រើរួចហើយនៅទីនេះ។

អ្នកអាចបញ្ចូលកូដប្រភពដោយផ្ទាល់ពីប្រភពបញ្ចូលដែលមិនគួរឱ្យទុកចិត្ត ឬបង្ខំឱ្យកម្មវិធីគេហទំព័រផ្ទុកវាពីប្រព័ន្ធឯកសារមូលដ្ឋាន ឬធនធានខាងក្រៅដូចជា URL ជាដើម។ នៅពេលដែលកូដត្រូវបានបញ្ចូលជាលទ្ធផលនៃការបញ្ចូលប្រភពខាងក្រៅ វាត្រូវបានសំដៅជាទូទៅថាជាការរួមបញ្ចូលឯកសារពីចម្ងាយ (RFI) ទោះបីជា RFI ខ្លួនវាតែងតែមានបំណងចាក់កូដក៏ដោយ។

ហេតុផលចម្បងសម្រាប់ការណែនាំកូដ៖

• ឆ្លងកាត់ការត្រួតពិនិត្យទិន្នន័យបញ្ចូល,
• ការចាក់បញ្ចូលដែលមិនគួរឱ្យទុកចិត្តទៅក្នុងបរិបទណាមួយដែលវានឹងត្រូវបានចាត់ទុកជាកូដ PHP,
• ការលួចចូលសុវត្ថិភាពនៃឃ្លាំងកូដប្រភព,
• បិទការព្រមានអំពីការផ្ទុកបណ្ណាល័យភាគីទីបី,
• កំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនមេឡើងវិញ ដូច្នេះវាបញ្ជូនឯកសារដែលមិនមែនជា PHP ទៅកាន់អ្នកបកប្រែ PHP ។

យកចិត្តទុកដាក់ជាពិសេសចំពោះចំណុចចុងក្រោយ៖ ក្នុងករណីនេះ អ្នកប្រើប្រាស់ដែលមិនគួរឱ្យទុកចិត្តអាចផ្ទុកឡើងឯកសារណាមួយទៅម៉ាស៊ីនមេ។

ឧទាហរណ៍នៃការចាក់កូដ

PHP មាន​គោលដៅ​ចាក់​កូដ​ច្រើន ដូច្នេះ​ការ​វាយ​ប្រហារ​ប្រភេទ​នេះ​ឈរ​លើ​បញ្ជី​មើល​របស់​អ្នក​សរសេរ​កម្មវិធី​ណា​មួយ​។

រួមទាំងឯកសារ

គោលដៅជាក់ស្តែងបំផុតសម្រាប់ការបញ្ចូលកូដគឺរួមមាន() រួមបញ្ចូល_once() ទាមទារ() និងមុខងារទាមទារ_once()។ ប្រសិនបើទិន្នន័យបញ្ចូលដែលមិនគួរឱ្យទុកចិត្តអនុញ្ញាតឱ្យអ្នកកំណត់ប៉ារ៉ាម៉ែត្រផ្លូវដែលបានបញ្ជូនទៅមុខងារទាំងនេះ នោះអ្នកអាចគ្រប់គ្រងពីចម្ងាយនូវឯកសារដែលត្រូវបញ្ចូល។ វាគួរតែត្រូវបានកត់សម្គាល់ថាឯកសារដែលបានរួមបញ្ចូលមិនត្រូវជាឯកសារ PHP ពិតប្រាកដណាមួយ ទ្រង់ទ្រាយឯកសារដែលមានសមត្ថភាពរក្សាទុកទិន្នន័យអត្ថបទអាចត្រូវបានប្រើ (ឧទាហរណ៍ស្ទើរតែគ្មានការរឹតបន្តឹង) ។

ប៉ារ៉ាម៉ែត្រផ្លូវក៏អាចងាយរងការវាយប្រហារពី Directory Traversal ឬការវាយប្រហារការបញ្ចូលឯកសារពីចម្ងាយផងដែរ។ ការប្រើបន្សំតួអក្សរ ../ ឬ ... នៅក្នុងផ្លូវអនុញ្ញាតឱ្យអ្នកវាយប្រហារលោតទៅស្ទើរតែគ្រប់ឯកសារដែលដំណើរការ PHP មានសិទ្ធិចូលប្រើ។ ក្នុងពេលជាមួយគ្នានេះ នៅក្នុងការកំណត់រចនាសម្ព័ន្ធ PHP លំនាំដើម មុខងារខាងលើទទួលយក URL លុះត្រាតែអនុញ្ញាត_url_រួមបញ្ចូលត្រូវបានបិទ។

ការប្រឡង

មុខងារ PHP eval() ទទួលយកបន្ទាត់នៃកូដ PHP សម្រាប់ប្រតិបត្តិ។

ការអនុវត្តកន្សោមធម្មតា។

អនុគមន៍ PCRE (Perl Compatible Regular Expression) preg_replace() នៅក្នុង PHP អនុញ្ញាតឱ្យប្រើ e modifier (PREG_REPLACE_EVAL)។ នេះមានន័យថាខ្សែអក្សរជំនួស ដែលបន្ទាប់ពីការជំនួសនឹងត្រូវបានចាត់ទុកថាជាកូដ PHP ។ ហើយប្រសិនបើមានការបញ្ចូលដែលមិនគួរឱ្យទុកចិត្តនៅក្នុងបន្ទាត់នោះ នោះពួកគេនឹងអាចបញ្ចូលកូដ PHP ដែលអាចប្រតិបត្តិបាន។

តក្កវិជ្ជានៃការរួមបញ្ចូលឯកសារដែលមានបញ្ហា

កម្មវិធីគេហទំព័រ តាមនិយមន័យ រួមបញ្ចូលឯកសារចាំបាច់សម្រាប់បម្រើសំណើណាមួយ។ ប្រសិនបើអ្នកទាញយកអត្ថប្រយោជន៍ពីភាពខ្វះខាតក្នុងតក្កកម្មផ្លូវ ការគ្រប់គ្រងភាពអាស្រ័យ ការផ្ទុកដោយស្វ័យប្រវត្តិ និងដំណើរការផ្សេងទៀត នោះការរៀបចំផ្លូវស្នើសុំ ឬប៉ារ៉ាម៉ែត្ររបស់វានឹងបង្ខំម៉ាស៊ីនមេឱ្យរួមបញ្ចូលឯកសារមូលដ្ឋានជាក់លាក់។ ដោយសារកម្មវិធីគេហទំព័រមិនត្រូវបានរចនាឡើងដើម្បីដោះស្រាយឧបាយកលបែបនេះ ផលវិបាកអាចមិនអាចទាយទុកជាមុនបាន។ ឧទាហរណ៍ កម្មវិធីនឹងបង្ហាញផ្លូវដែលមានបំណងសម្រាប់តែប្រើនៅលើបន្ទាត់ពាក្យបញ្ជាដោយមិនដឹងខ្លួន។ ឬ​វា​នឹង​បង្ហាញ​ថ្នាក់​ផ្សេង​ទៀត​ដែល​អ្នក​សាងសង់​ធ្វើ​កិច្ចការ (វា​ល្អ​ជាង​មិន​ត្រូវ​រចនា​ថ្នាក់​តាម​វិធី​នេះ​ទេ ប៉ុន្តែ​វា​នៅ​តែ​កើត​ឡើង)។ គ្រប់សេណារីយ៉ូទាំងនេះអាចរំខានដល់ប្រតិបត្តិការផ្នែកខាងក្រោយរបស់កម្មវិធី ដែលអនុញ្ញាតឱ្យមានការគ្រប់គ្រងទិន្នន័យ ឬការវាយប្រហារដោយ DOS លើប្រតិបត្តិការដែលពឹងផ្អែកខ្លាំងលើធនធានដែលមិនពាក់ព័ន្ធនឹងការចូលប្រើដោយផ្ទាល់។

បញ្ហាប្រឈមនៃការចាក់កូដ

ជួរនៃកិច្ចការគឺធំទូលាយណាស់ ដោយសារប្រភេទនៃការវាយប្រហារនេះអនុញ្ញាតឱ្យអ្នកប្រតិបត្តិកូដ PHP ណាមួយដែលអ្នកវាយប្រហារជ្រើសរើស។

ការការពារប្រឆាំងនឹង Code InjectionCommand Injection ឧទាហរណ៍នៃ Command Injection ការការពារប្រឆាំងនឹង Command InjectionLog Injection (ដែលគេស្គាល់ថាជា Log File Injection)

កម្មវិធីជាច្រើនប្រមូលកំណត់ហេតុ ហើយអ្នកប្រើប្រាស់ដែលមានការអនុញ្ញាតច្រើនតែមើលពួកវាតាមរយៈចំណុចប្រទាក់ HTML ។ ដូច្នេះ កំណត់ហេតុគឺជាគោលដៅចម្បងមួយរបស់អ្នកវាយប្រហារដែលចង់ក្លែងបន្លំការវាយប្រហារផ្សេងទៀត បញ្ឆោតអ្នកដែលមើលកំណត់ហេតុ ហើយបន្ទាប់មកថែមទាំងវាយប្រហារអ្នកប្រើប្រាស់កម្មវិធីត្រួតពិនិត្យដែលកំណត់ហេតុត្រូវបានអាន និងវិភាគ។

ភាពងាយរងគ្រោះនៃកំណត់ហេតុអាស្រ័យទៅលើយន្តការគ្រប់គ្រងលើការកត់ត្រាកំណត់ហេតុ ក៏ដូចជាលើការចាត់ចែងទិន្នន័យកំណត់ហេតុជាប្រភពដែលមិនគួរឱ្យទុកចិត្តនៅពេលមើល និងវិភាគកំណត់ហេតុ។

ប្រព័ន្ធកត់ត្រាសាមញ្ញអាចសរសេរខ្សែអក្សរទៅឯកសារដោយប្រើ file_put_contents() ។ ឧទាហរណ៍ អ្នកសរសេរកម្មវិធីកត់ត្រាការប៉ុនប៉ងអនុញ្ញាតមិនបានសម្រេចជាខ្សែអក្សរនៃទម្រង់ខាងក្រោម៖

sprintf("បរាជ័យក្នុងការប៉ុនប៉ងចូលដោយ %s", $username);

ចុះបើអ្នកវាយប្រហារប្រើឈ្មោះ “AdminnSuccessful login by Adminn” នៅលើទម្រង់បែបបទ?

ប្រសិនបើបន្ទាត់នេះត្រូវបានបញ្ចូលទៅក្នុងកំណត់ហេតុពីទិន្នន័យបញ្ចូលដែលមិនគួរឱ្យទុកចិត្ត នោះអ្នកវាយប្រហារនឹងក្លែងបន្លំការប៉ុនប៉ងអនុញ្ញាតដែលមិនបានសម្រេចដោយជោគជ័យដោយប្រើការបរាជ័យគ្មានកំហុសក្នុងការបញ្ចូលពាក្យសម្ងាត់អ្នកគ្រប់គ្រង។ ភាពសង្ស័យនៃទិន្នន័យនឹងត្រូវបានកាត់បន្ថយកាន់តែច្រើន ប្រសិនបើអ្នកបន្ថែមការព្យាយាមអនុញ្ញាតដោយជោគជ័យ។

ចំណុចទាំងមូលនៅទីនេះគឺថា អ្នកវាយប្រហារអាចបន្ថែមធាតុគ្រប់ប្រភេទទៅក្នុងកំណត់ហេតុ។ អ្នកក៏អាចចាក់វ៉ិចទ័រ XSS និងសូម្បីតែតួអក្សរដែលធ្វើឱ្យធាតុកំណត់ហេតុពិបាកអាននៅក្នុងកុងសូល។

កំណត់ហេតុការងារ

គោលដៅមួយនៃការអនុវត្តគឺអ្នកបកប្រែទម្រង់កំណត់ហេតុ។ ប្រសិនបើឧបករណ៍វិភាគប្រើកន្សោមធម្មតាដើម្បីញែកធាតុកំណត់ហេតុដើម្បីបំបែកពួកវាទៅក្នុងវាលផ្សេងៗគ្នា នោះវាអាចទៅរួចដើម្បីបង្កើត និងបញ្ចូលខ្សែអក្សរដែលបណ្តាលឱ្យកន្សោមធម្មតាជ្រើសរើសវាលដែលបានចាក់ជំនួសឱ្យត្រឹមត្រូវ។ ឧទាហរណ៍ ធាតុនេះអាចបណ្តាលឱ្យមានបញ្ហាជាច្រើន៖

$username = "iamnothacker! at Mon Jan 01 00:00:00 +1000 2009"; sprintf("បរាជ័យក្នុងការប៉ុនប៉ងចូលដោយ %s នៅ %s", $username,)

ការវាយប្រហារលើកំណត់ហេតុដែលស្មុគ្រស្មាញជាងមុន ពឹងផ្អែកលើការវាយប្រហារឆ្លងកាត់ថត ដើម្បីបង្ហាញកំណត់ហេតុនៅក្នុងកម្មវិធីរុករក។ នៅក្រោមលក្ខខណ្ឌត្រឹមត្រូវ ការចាក់បញ្ចូលកូដ PHP ទៅក្នុងសារកំណត់ហេតុ និងបើកឯកសារកំណត់ហេតុក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិតនឹងនាំឱ្យការបញ្ចូលកូដជោគជ័យដែលត្រូវបានធ្វើទ្រង់ទ្រាយ និងប្រតិបត្តិយ៉ាងស្អាតតាមសំណើរបស់អ្នកវាយប្រហារ។ ហើយប្រសិនបើវាមកដល់ការប្រតិបត្តិ PHP ព្យាបាទនៅលើម៉ាស៊ីនមេ នោះយើងអាចសង្ឃឹមបានតែចំពោះប្រសិទ្ធភាពនៃស្រទាប់ការពារ ដែលអាចកាត់បន្ថយការខូចខាតបាន។

ការការពារការចាក់ចូល

មធ្យោបាយងាយស្រួលបំផុតដើម្បីត្រងសារកំណត់ហេតុខាងក្រៅទាំងអស់គឺត្រូវប្រើបញ្ជីស។ ឧបមាថាយើងកំណត់តួអក្សរកំណត់ត្រឹមលេខ អក្សរ និងដកឃ្លាប៉ុណ្ណោះ។ សារដែលមានតួអក្សរដែលគ្មានការអនុញ្ញាតត្រូវបានចាត់ទុកថាខូច។ បន្ទាប់មកធាតុមួយនឹងលេចឡើងនៅក្នុងកំណត់ហេតុអំពីការប៉ុនប៉ងដែលមានសក្តានុពលក្នុងការបញ្ចូលឯកសារកំណត់ហេតុ។ នេះគឺជាវិធីសាស្ត្រសុវត្ថិភាពសាមញ្ញសម្រាប់កំណត់ហេតុអត្ថបទសាមញ្ញ ដែលសារមិនអាចជៀសវាងពីការរួមបញ្ចូលទិន្នន័យបញ្ចូលដែលមិនគួរឱ្យទុកចិត្ត។

វិធីសាស្ត្រការពារទីពីរគឺដើម្បីបំប្លែងបំណែកនៃទិន្នន័យបញ្ចូលដែលមិនគួរឱ្យទុកចិត្តដោយប្រើប្រព័ន្ធដូចជា base64 ដែលគាំទ្រសំណុំតួអក្សរដែលមានកំណត់ ខណៈពេលដែលនៅតែអនុញ្ញាតឱ្យផ្ទុកព័ត៌មានផ្សេងៗក្នុងទម្រង់ជាអត្ថបទ។

ផ្លូវឆ្លងកាត់ (គេស្គាល់ថាជា Directory Traversal)

ការវាយប្រហារឆ្លងកាត់ផ្លូវគឺជាការប៉ុនប៉ងប៉ះពាល់ដល់ប្រតិបត្តិការអាន ឬសរសេរឯកសារនៅលើផ្នែកខាងក្រោយនៃកម្មវិធីគេហទំព័រ។ នេះត្រូវបានធ្វើដោយការណែនាំប៉ារ៉ាម៉ែត្រដែលអនុញ្ញាតឱ្យអ្នករៀបចំផ្លូវនៃឯកសារដែលពាក់ព័ន្ធនឹងប្រតិបត្តិការផ្នែកខាងក្រោយ។ ដូច្នេះប្រភេទនៃការវាយប្រហារនេះជួយសម្រួលដល់ការបង្ហាញព័ត៌មាន និងការបញ្ចូលឯកសារក្នុងមូលដ្ឋាន/ពីចម្ងាយ។

យើងនឹងពិចារណាការវាយប្រហារបែបនេះដោយឡែកពីគ្នា ប៉ុន្តែមូលដ្ឋាននៃភាពជោគជ័យរបស់ពួកគេស្ថិតនៅយ៉ាងជាក់លាក់ក្នុងការឆ្លងកាត់ផ្លូវ។ ដោយសារមុខងារដែលបានពិពណ៌នាខាងក្រោមគឺជាក់លាក់ចំពោះការរៀបចំផ្លូវឯកសារ វាសមហេតុផលក្នុងការនិយាយថាមុខងារ PHP ជាច្រើនមិនទទួលយកផ្លូវឯកសារក្នុងន័យធម្មតានៃពាក្យនោះទេ។ ជំនួសមកវិញ មុខងារដូចជា include() ឬ file() ទទួលយក URI មួយ។

វាមើលទៅខុសពីធម្មជាតិទាំងស្រុង។ ប៉ុន្តែនេះមានន័យថាការហៅមុខងារពីរខាងក្រោមគឺសមមូល ដែលប្រើផ្លូវដាច់ខាត (ឧទាហរណ៍ ដោយមិនពឹងផ្អែកលើការផ្ទុកផ្លូវដែលទាក់ទងដោយស្វ័យប្រវត្តិ)។

រួមបញ្ចូល('/var/www/vendor/library/Class.php'); include('file:///var/www/vendor/library/Class.php');

រឿងនេះគឺថាផ្លូវដែលទាក់ទងត្រូវបានដំណើរការនៅចំហៀង (ការកំណត់ include_path នៅក្នុង php.ini និង autoloaders ដែលមាន)។ ក្នុងករណីបែបនេះ មុខងារ PHP ងាយរងគ្រោះចំពោះទម្រង់ជាច្រើននៃការរៀបចំប៉ារ៉ាម៉ែត្រ រួមទាំង File URI Scheme Substitution ដែលអ្នកវាយប្រហារអាចចាក់ HTTP ឬ FTP URI ប្រសិនបើទិន្នន័យមិនគួរឱ្យទុកចិត្តត្រូវបានបង្កប់នៅដើមផ្លូវឯកសារ។ យើងនឹងនិយាយអំពីរឿងនេះឱ្យបានលម្អិតនៅក្នុងផ្នែកអំពីការវាយប្រហារការបញ្ចូលឯកសារពីចម្ងាយ ប៉ុន្តែសម្រាប់ពេលនេះ យើងនឹងផ្តោតលើការឆ្លងកាត់ផ្លូវប្រព័ន្ធឯកសារ។

ភាពងាយរងគ្រោះនេះពាក់ព័ន្ធនឹងការផ្លាស់ប្តូរផ្លូវដើម្បីចូលប្រើឯកសារផ្សេងទៀត។ ជាធម្មតា នេះត្រូវបានសម្រេចដោយការបញ្ចូលស៊េរីនៃ ../ sequences ទៅក្នុងអាគុយម៉ង់ ដែលបន្ទាប់មកត្រូវបានបន្ថែមទៅមុខងារ ឬបញ្ចូលទាំងស្រុងទៅក្នុងមុខងារដូចជា include() , require() , file_get_contents() និងសូម្បីតែមុខងារដែលគួរឱ្យសង្ស័យតិចជាង (ចំពោះមុខងារមួយចំនួន) ដូចជា DOMDocument: :load() ។

ដោយប្រើលំដាប់ ../ អ្នកវាយប្រហារបង្ខំឱ្យប្រព័ន្ធត្រឡប់ទៅថតមេវិញ។ ដូច្នេះផ្លូវ /var/www/public/../vendor ពិតជាទៅកាន់ /var/www/vendor . លំដាប់ ../ after /public នាំយើងត្រឡប់ទៅថតមេ ពោលគឺ /var/www. វាអនុញ្ញាតឱ្យអ្នកវាយប្រហារចូលប្រើឯកសារដែលមានទីតាំងនៅខាងក្រៅ / ថតសាធារណៈដែលអាចចូលប្រើបានពីម៉ាស៊ីនមេគេហទំព័រ។

ជាការពិតណាស់ ការឆ្លងកាត់ផ្លូវមួយមិនត្រូវបានកំណត់ត្រឹមតែការត្រឡប់មកវិញនោះទេ។ អ្នក​អាច​អនុវត្ត​ធាតុ​ផ្លូវ​ថ្មី​ដើម្បី​ទទួល​បាន​សិទ្ធិ​ចូល​ទៅ​កាន់​ថត​កូន​ដែល​មិន​អាច​ចូល​ដំណើរការ​បាន​ពី​កម្មវិធី​រុករក​ដោយ​សារ​តែ​ការ​កំណត់​ការ​រឹតត្បិត​ក្នុង .htaccess។ ប្រតិបត្តិការ​ប្រព័ន្ធ​ឯកសារ PHP មិន​ខ្វល់​អំពី​ការ​កំណត់​រចនាសម្ព័ន្ធ​ការ​គ្រប់គ្រង​ការ​ចូល​ដំណើរការ​នៃ​ឯកសារ និង​ថត​ដែល​មិន​មែន​ជា​សាធារណៈ​នៅ​លើ​ម៉ាស៊ីន​បម្រើ​បណ្ដាញ​ទេ។

ឧទាហរណ៍នៃផ្លូវ TraversalDefenses ប្រឆាំងនឹង Path TraversalXML Injection

ទោះបីជាមានការណែនាំអំពី JSON ជាមធ្យោបាយស្រាលនៃការផ្ទេរទិន្នន័យរវាងម៉ាស៊ីនមេ និងអតិថិជនក៏ដោយ XML នៅតែជាជម្រើសដ៏ពេញនិយម ហើយ APIs សេវាកម្មគេហទំព័រតែងតែគាំទ្រវាស្របគ្នាជាមួយ JSON ។ XML ក៏ត្រូវបានប្រើដើម្បីផ្លាស់ប្តូរទិន្នន័យដោយប្រើគ្រោងការណ៍ XML: RSS, Atom, SOAP និង RDF ជាដើម។

XML មានគ្រប់ទីកន្លែង៖ វាអាចត្រូវបានរកឃើញនៅក្នុងម៉ាស៊ីនមេកម្មវិធីគេហទំព័រ កម្មវិធីរុករក (ជាទម្រង់ដែលពេញចិត្តសម្រាប់សំណើ និងការឆ្លើយតប XMLHttpRequest) និងផ្នែកបន្ថែមកម្មវិធីរុករក។ ដោយសារភាពប្រេវ៉ាឡង់ និងដំណើរការលំនាំដើមរបស់វាដោយអ្នកញែកដ៏ពេញនិយមដូចជា libxml2 ដែលប្រើដោយ PHP នៅក្នុង DOM និងនៅក្នុងផ្នែកបន្ថែម SimpleXML និង XMLReader XML បានក្លាយជាគោលដៅសម្រាប់ការវាយប្រហារដោយការចាក់។ នៅពេលដែលកម្មវិធីរុករកបានចូលរួមយ៉ាងសកម្មនៅក្នុងការផ្លាស់ប្តូរ XML វាត្រូវតែត្រូវបានយកទៅក្នុងគណនីថាតាមរយៈ XSS អ្នកប្រើប្រាស់ដែលមានការអនុញ្ញាតអាចបញ្ជូនសំណើ XML ដែលពិតជាត្រូវបានបង្កើតឡើងដោយអ្នកវាយប្រហារ។

ការបង្កប់ធាតុខាងក្រៅ XML (XXE)

ការ​វាយ​ប្រហារ​ទាំង​នេះ​មាន​ដោយ​សារ​បណ្ណាល័យ​វិភាគ XML ជា​ញឹក​ញាប់​គាំទ្រ​ការ​ប្រើ​ឯកសារ​យោង​អង្គភាព​ផ្ទាល់​ខ្លួន។ អ្នក​នឹង​រៀន​អំពី​ការ​បំពេញ​អង្គភាព XML ស្តង់ដារ ដែល​ត្រូវ​បាន​ប្រើ​ដើម្បី​តំណាង​ឱ្យ​តួអក្សរ​សម្គាល់​ពិសេស​ដូច​ជា > , < ; និង & apos ។ XML អនុញ្ញាតឱ្យអ្នកពង្រីកសំណុំនៃអង្គភាពស្តង់ដារដោយកំណត់អង្គភាពផ្ទាល់ខ្លួនតាមរយៈឯកសារ XML ដោយខ្លួនឯង។ ពួកវាអាចត្រូវបានកំណត់ដោយការរួមបញ្ចូលដោយផ្ទាល់នៅក្នុង DOCTYPE ជាជម្រើស។ តម្លៃបន្ថែមដែលពួកគេតំណាងអាចសំដៅទៅលើធនធានខាងក្រៅដែលគួរតែត្រូវបានរួមបញ្ចូល។ ការវាយប្រហារ XXE បានក្លាយជាការពេញនិយមយ៉ាងជាក់លាក់ដោយសារតែសមត្ថភាពរបស់ XML ធម្មតាក្នុងការរក្សាទុកតំណភ្ជាប់ផ្ទាល់ខ្លួនដែលអាចត្រូវបានពង្រីកដោយសារតែមាតិកានៃធនធានខាងក្រៅ។ នៅក្រោមកាលៈទេសៈធម្មតា ធាតុចូលដែលមិនគួរឱ្យទុកចិត្តមិនគួរមានអន្តរកម្មជាមួយប្រព័ន្ធរបស់យើងតាមរបៀបដែលមិនបានរំពឹងទុកឡើយ។ ហើយអ្នកសរសេរកម្មវិធី XXE ភាគច្រើនស្ទើរតែមិនបានឃើញការវាយប្រហារ XXE ដែលជាកង្វល់ជាពិសេស។

ជាឧទាហរណ៍ ចូរកំណត់អង្គភាពផ្ទាល់ខ្លួនថ្មីដែលមិនបង្កគ្រោះថ្នាក់៖

ឯកសារ XML ដែល​មាន​និយមន័យ​នេះ​ឥឡូវ​នេះ​អាច​យោង​ទៅ​លើ​អង្គភាព​នៅ​គ្រប់​ទីកន្លែង​ដែល​អង្គភាព​ត្រូវ​បាន​អនុញ្ញាត​ជា​ទូទៅ៖

លទ្ធផលនេះគឺ

នៅពេលដែលកម្មវិធីញែក XML ដូចជា PHP DOM បកស្រាយ XML នេះ វានឹងដំណើរការអង្គភាពផ្ទាល់ខ្លួននេះភ្លាមៗនៅពេលដែលឯកសារត្រូវបានផ្ទុក។ ដូច្នេះ នៅពេលស្នើសុំអត្ថបទដែលត្រូវគ្នា វានឹងត្រឡប់ដូចតទៅ៖

លទ្ធផលនេះគឺគ្មានគ្រោះថ្នាក់ទាំងស្រុងទេ។

ជាក់ស្តែង អង្គភាពផ្ទាល់ខ្លួនមានអត្ថប្រយោជន៍ក្នុងការតំណាងឱ្យអត្ថបទដដែលៗ និង XML ជាមួយនឹងឈ្មោះអង្គភាពខ្លីជាង។ ជារឿយៗវាជាករណីដែល XML ត្រូវតែធ្វើតាមវេយ្យាករណ៍ជាក់លាក់មួយ ហើយអង្គភាពផ្ទាល់ខ្លួនធ្វើឱ្យការកែសម្រួលកាន់តែងាយស្រួល។ ទោះយ៉ាងណាក៏ដោយ ដោយសារការមិនទុកចិត្តរបស់យើងចំពោះការបញ្ចូលខាងក្រៅ យើងត្រូវប្រុងប្រយ័ត្នខ្ពស់ជាមួយនឹងកម្មវិធី XML ណាមួយរបស់យើងប្រើប្រាស់។ ឧទាហរណ៍ នេះមិនមែនជាប្រភេទសុវត្ថិភាពទាល់តែសោះ៖

&harmless;

អាស្រ័យលើខ្លឹមសារនៃឯកសារមូលដ្ឋានដែលបានស្នើសុំ ទិន្នន័យអាចនឹងត្រូវបានប្រើប្រាស់នៅពេលពង្រីកអង្គភាព។ ហើយបន្ទាប់មកមាតិកាដែលបានពង្រីកអាចត្រូវបានស្រង់ចេញពីឧបករណ៍ញែក XML និងរួមបញ្ចូលនៅក្នុងទិន្នន័យចេញនៃកម្មវិធីគេហទំព័រសម្រាប់ការវិភាគដោយអ្នកវាយប្រហារ។ ឧទាហរណ៍ដើម្បីបង្ហាញព័ត៌មាន។ ឯកសារដែលបានស្រង់ចេញនឹងត្រូវបានបកប្រែជា XML ទោះបីជាមិនមានតួអក្សរពិសេសដើម្បីចាប់ផ្តើមការបកស្រាយនេះក៏ដោយ។ វាកំណត់វិសាលភាពដែលមាតិកានៃឯកសារមូលដ្ឋានអាចត្រូវបានលាតត្រដាង។ ប្រសិនបើឯកសារត្រូវបានបកស្រាយថាជា XML ប៉ុន្តែមិនមាន XML ត្រឹមត្រូវទេ នោះយើងទំនងជានឹងទទួលបានកំហុស ដែលនឹងរារាំងខ្លឹមសារមិនឱ្យបង្ហាញ។ ទោះជាយ៉ាងណាក៏ដោយ PHP មានល្បិចដ៏ប្រណិតដែលអាចរកបានដើម្បីរំលងដែនកំណត់វិសាលភាព ដូច្នេះសំណើ HTTP ពីចម្ងាយប៉ះពាល់ដល់កម្មវិធីគេហទំព័រ ទោះបីជាការឆ្លើយតបដែលត្រឡប់មកវិញមិនអាចបញ្ជូនត្រឡប់ទៅអ្នកវាយប្រហារវិញក៏ដោយ។

មានវិធីសាស្រ្តដែលប្រើជាទូទៅចំនួនបីសម្រាប់ញែក និងប្រើប្រាស់ XML ក្នុង PHP: PHP DOM, SimpleXML, និង XMLReader ។ ពួកគេទាំងអស់ប្រើផ្នែកបន្ថែម libxml2 ហើយការគាំទ្រសម្រាប់អង្គភាពខាងក្រៅត្រូវបានបើកតាមលំនាំដើម។ ជាលទ្ធផល PHP ងាយរងការវាយប្រហារ XXE តាមលំនាំដើម ដែលវាងាយនឹងខកខាននៅពេលពិចារណាលើសុវត្ថិភាពនៃកម្មវិធីគេហទំព័រ ឬបណ្ណាល័យដែលប្រើ XML ។

កុំភ្លេចផងដែរថា XHTML និង HTML 5 អាចត្រូវបានសៀរៀលជា XML ត្រឹមត្រូវ។ នេះមានន័យថាទំព័រ XHTML មួយចំនួន ឬ XML-serialized HTML 5 អាចញែកជា XML ដោយប្រើ DOMDocument::loadXML() ជំនួសឱ្យ DOMDocument::loadHTML() ។ ការប្រើប្រាស់ឧបករណ៍ញែក XML នេះក៏ងាយរងគ្រោះផងដែរក្នុងការចាក់បញ្ចូលធាតុ XML ខាងក្រៅ។ សូមចងចាំថា libxml2 មិនទាន់ស្គាល់ HTML 5 DOCTYPE នៅឡើយទេ ដូច្នេះវាមិនអាចផ្ទៀងផ្ទាត់វាជា XHTML DOCTYPES បានទេ។

ឧទាហរណ៍នៃការអនុវត្តអង្គភាព XML ខាងក្រៅខ្លឹមសារ និងការបង្ហាញឯកសារ

យើងបានមើលឧទាហរណ៍នៃការបង្ហាញព័ត៌មានខាងលើ ដោយកត់សម្គាល់ថាអង្គភាព XML ផ្ទាល់ខ្លួនអាចយោងឯកសារខាងក្រៅ។

&harmless;

ក្នុងករណីនេះ អង្គភាពផ្ទាល់ខ្លួននឹងត្រូវបានពង្រីកជាមួយនឹងមាតិកានៃឯកសារ។ ដោយសារសំណើបែបនេះទាំងអស់ត្រូវបានអនុវត្តនៅក្នុងមូលដ្ឋាន នេះអនុញ្ញាតឱ្យមាតិកានៃឯកសារទាំងអស់ដែលកម្មវិធីអាចអានត្រូវបានលាតត្រដាង។ នោះគឺនៅពេលដែលអង្គភាពបន្ថែមត្រូវបានរួមបញ្ចូលនៅក្នុងទិន្នន័យចេញនៃកម្មវិធី អ្នកវាយប្រហារនឹងអាចពិនិត្យមើលឯកសារដែលមិនអាចចូលដំណើរការបាន។ ទោះយ៉ាងណាក៏ដោយ ក្នុងករណីនេះមានដែនកំណត់ធ្ងន់ធ្ងរ៖ ឯកសារត្រូវតែជាទម្រង់ XML ឬជាទម្រង់ដែលនឹងមិននាំទៅដល់កំហុសក្នុងការញែក XML ទេ។ ប៉ុន្តែចំនុចនោះគឺថាការកំណត់នេះអាចត្រូវបានមិនអើពើទាំងស្រុងនៅក្នុង PHP៖

&harmless;

PHP ផ្តល់នូវការចូលទៅកាន់ wrapper ជា URI ដែលជាពិធីការមួយដែលត្រូវបានទទួលយកដោយមុខងារស្តង់ដាររបស់ប្រព័ន្ធឯកសារ៖ file_get_contents(), require(), require_once(), file(), copy() និងផ្សេងៗទៀត។ កម្មវិធីរុំ PHP គាំទ្រតម្រងមួយចំនួនដែលអាចត្រូវបានអនុវត្តទៅធនធានជាក់លាក់មួយ ដូច្នេះលទ្ធផលត្រូវបានបញ្ជូនមកវិញដោយការហៅមុខងារមួយ។ ក្នុងឧទាហរណ៍ខាងលើ យើងអនុវត្តតម្រង convert.base-64-encode ទៅឯកសារគោលដៅដែលយើងចង់អាន។

នេះមានន័យថាអ្នកវាយប្រហារអាចអានឯកសារណាមួយដែលមាននៅក្នុង PHP ដោយមិនគិតពីទម្រង់អត្ថបទ។ វាគ្រប់គ្រាន់ហើយក្នុងការឌិកូដទិន្នន័យដែលបានមកពីកម្មវិធី ហើយបន្ទាប់មកបំបែកវាដោយនិទណ្ឌភាព។ ទោះបីជាវាមិនប៉ះពាល់ដោយផ្ទាល់ដល់អ្នកប្រើប្រាស់ចុងក្រោយ ឬផ្នែកខាងក្រោយនៃកម្មវិធីក៏ដោយ ក៏វាអនុញ្ញាតឱ្យអ្នកវាយប្រហារសិក្សារចនាសម្ព័ន្ធកម្មវិធីឱ្យបានហ្មត់ចត់ ដើម្បីព្យាយាមស្វែងរកភាពងាយរងគ្រោះផ្សេងទៀត។ លើសពីនេះទៅទៀត ហានិភ័យដែលអ្នកវាយប្រហារនឹងត្រូវបានរកឃើញគឺតិចតួចបំផុត។

ការគ្រប់គ្រងការចូលប្រើផ្លូវវាង

ការចូលប្រើត្រូវបានគ្រប់គ្រងតាមវិធីផ្សេងៗគ្នា។ ដោយសារការវាយប្រហារ XXE ត្រូវបានអនុវត្តនៅលើផ្នែកខាងក្រោយនៃកម្មវិធីបណ្តាញ វានឹងមិនអាចប្រើសម័យរបស់អ្នកប្រើប្រាស់បច្ចុប្បន្នបានទេ។ ប៉ុន្តែអ្នកវាយប្រហារនៅតែអាចឆ្លងកាត់ការគ្រប់គ្រងការចូលប្រើទៅកាន់ផ្នែកខាងក្រោយដោយប្រើសំណើពីម៉ាស៊ីនមេក្នុងស្រុក។ ពិចារណាលើការគ្រប់គ្រងការចូលប្រើដំបូងនេះ៖

ប្រសិនបើ (isset($_SERVER["HTTP_CLIENT_IP"]) || isset($_SERVER["HTTP_X_FORWARDED_FOR"]) || !in_array(@$_SERVER["REMOTE_ADDR"], អារេ("127.0.0.1", "::1 ",))) (បឋមកថា("HTTP/1.0 403 Forbidden"); ចេញ("អ្នកមិនត្រូវបានអនុញ្ញាតឱ្យចូលប្រើឯកសារនេះទេ។");)

បំណែកនៃ PHP នេះដូចជាអ្នកផ្សេងទៀតរាប់មិនអស់ចូលចិត្តវា រឹតបន្តឹងការចូលប្រើឯកសារ PHP ជាក់លាក់នៅលើម៉ាស៊ីនមេក្នុងស្រុក ពោលគឺ localhost ។ ទោះជាយ៉ាងណាក៏ដោយ ការវាយប្រហារ XXE លើផ្នែកខាងមុខនៃកម្មវិធីផ្តល់ឱ្យអ្នកវាយប្រហារនូវព័ត៌មានសម្ងាត់ពិតប្រាកដដែលត្រូវការដើម្បីរំលងការគ្រប់គ្រងការចូលប្រើទាំងនេះ ពីព្រោះសំណើ HTTP ទាំងអស់ទៅកាន់ឧបករណ៍ញែក XML នឹងត្រូវបានធ្វើឡើងពីម៉ាស៊ីនមូលដ្ឋាន។

&harmless;

ទោះបីជាការមើលកំណត់ហេតុត្រូវបានកំណត់ចំពោះសំណើក្នុងស្រុកក៏ដោយ អ្នកវាយប្រហារនឹងនៅតែអាចទទួលបានកំណត់ហេតុ។ អនុវត្តដូចគ្នាចំពោះចំណុចប្រទាក់ថែទាំ ឬការគ្រប់គ្រង ការចូលប្រើដែលត្រូវបានកំណត់តាមវិធីនេះ។

ការវាយប្រហារ DOS

ស្ទើរតែទាំងអស់ដែលកំណត់ការប្រើប្រាស់ធនធានម៉ាស៊ីនមេ អាចត្រូវបានប្រើសម្រាប់ការវាយប្រហារ DOS ។ តាមរយៈការចាក់បញ្ចូលធាតុ XML ខាងក្រៅ អ្នកវាយប្រហារអាចបង្កើតសំណើ HTTP តាមអំពើចិត្ត ដែលនៅក្រោមលក្ខខណ្ឌត្រឹមត្រូវ បង្ហូរធនធានម៉ាស៊ីនមេ។

យើងនឹងនិយាយនៅពេលក្រោយអំពីការប្រើប្រាស់ DOS ដែលមានសក្តានុពលផ្សេងទៀតនៃការវាយប្រហារ XXE ទាក់ទងនឹងការពង្រីកអង្គភាព XML ។

ការការពារប្រឆាំងនឹងការចាក់បញ្ចូលធាតុ XML ខាងក្រៅ

ការវាយប្រហារទាំងនេះមានប្រជាប្រិយភាពខ្លាំងណាស់ ដូច្នេះអ្នកនឹងភ្ញាក់ផ្អើលពីរបៀបដែលវាងាយស្រួលក្នុងការការពារប្រឆាំងនឹងពួកគេ។ ដោយសារ DOM, SimpleXML និង XMLReader ពឹងផ្អែកលើ libxml2 អ្នកអាចប្រើមុខងារ libxml_disable_entity_loader() ដើម្បីបិទការប្រើប្រាស់ធាតុខាងក្រៅ។ ទោះយ៉ាងណាក៏ដោយ វានឹងមិនបិទដំណើរការអង្គភាពផ្ទាល់ខ្លួនដែលត្រូវបានកំណត់ជាមុននៅក្នុង DOCTYPE ទេ ពីព្រោះពួកគេមិនប្រើធនធានខាងក្រៅដែលទាមទារសំណើ HTTP ឬប្រតិបត្តិការប្រព័ន្ធឯកសារ។

$oldValue = libxml_disable_entity_loader(ពិត); $dom = ថ្មី DOMDocument(); $dom->loadXML($xml); libxml_disable_entity_loader($oldValue);

វាត្រូវតែធ្វើសម្រាប់ប្រតិបត្តិការទាំងអស់ដែលពាក់ព័ន្ធនឹងការផ្ទុក XML ពីខ្សែអក្សរ ឯកសារ ឬ URI ពីចម្ងាយ។

នៅពេលដែលកម្មវិធីមិនតម្រូវឱ្យមានអង្គភាពខាងក្រៅ ហើយសម្រាប់សំណើភាគច្រើនរបស់វា ការផ្ទុកធនធានខាងក្រៅអាចត្រូវបានបិទទាំងស្រុងនៅកម្រិតសកលបន្ថែមទៀត។ ក្នុងករណីភាគច្រើន នេះគឺល្អជាងសម្រាប់ការកំណត់ចំណុចផ្ទុក XML ទាំងអស់ ដោយសារបណ្ណាល័យជាច្រើនមានភាពងាយរងគ្រោះចំពោះការវាយប្រហារ XXE៖

libxml_disable_entity_loader(ពិត);

គ្រាន់តែចងចាំដើម្បីត្រឡប់ TRUE បន្ទាប់ពីការបើកដំណើរការបណ្តោះអាសន្ននីមួយៗនៃការផ្ទុកធនធានខាងក្រៅ។ អ្នកប្រហែលជាត្រូវការវាសម្រាប់អ្វីមួយដែលគ្មានកំហុសដូចការបំប្លែង Docbook XML ទៅជា HTML ដែលកម្មវិធីនៃរចនាប័ទ្ម XSL អាស្រ័យលើធាតុខាងក្រៅ។

ទោះយ៉ាងណាក៏ដោយ មុខងារបិទ libxml2 មិនមែនជា panacea ទេ។ វិភាគផ្នែកបន្ថែមផ្សេងទៀត និងបណ្ណាល័យ PHP ដែលញែក ឬដំណើរការ XML ដើម្បីស្វែងរក "ឧបករណ៍ប្តូរ" របស់ពួកគេសម្រាប់ការប្រើប្រាស់ធាតុខាងក្រៅ។

ប្រសិនបើវាមិនអាចទៅរួច នោះពិនិត្យមើលបន្ថែមថាតើឯកសារ XML ប្រកាស DOCTYPE ដែរឬទេ។ ប្រសិនបើដូច្នេះ ហើយប្រសិនបើអង្គភាពខាងក្រៅត្រូវបានបិទ នោះគ្រាន់តែបោះចោលឯកសារ XML ដោយបដិសេធការចូលប្រើ XML ដែលមិនគួរឱ្យទុកចិត្តទៅកាន់ឧបករណ៍ញែកដែលងាយរងគ្រោះ ហើយកត់ត្រាវាជាការវាយប្រហារដែលទំនង។ នេះគឺជាជំហានចាំបាច់ព្រោះវានឹងមិនមានសញ្ញាផ្សេងទៀត - គ្មានកំហុស គ្មានករណីលើកលែង។ បង្កើតការត្រួតពិនិត្យនេះទៅក្នុងភាពត្រឹមត្រូវនៃការបញ្ចូលជាប្រចាំរបស់អ្នក។ ប៉ុន្តែវិធីសាស្រ្តនេះគឺនៅឆ្ងាយពីឧត្តមគតិ ដូច្នេះវាត្រូវបានផ្ដល់អនុសាសន៍យ៉ាងខ្លាំងដើម្បីដោះស្រាយបញ្ហាជាមូលដ្ឋាននៃអង្គភាពខាងក្រៅ។

/** * ព្យាយាមស្វែងរករហ័ស */ $collapsedXML = preg_replace("/[:space:]/", "", $xml); ប្រសិនបើ(preg_match("/