ប្រសិនបើអ្នកប្រើ stripchar ដើម្បីសម្អាតការបញ្ចូលរបស់អ្នកប្រើប្រាស់ អ្នកមិនឯកាទេ។ អ្នកអភិវឌ្ឍន៍ជាច្រើនពឹងផ្អែកលើប្រភេទនេះ ការបញ្ចូលអនាម័យ ដើម្បីរារាំងការប៉ុនប៉ងចាក់។ នៅពេលមើលដំបូង វាហាក់ដូចជាសមហេតុផល លុបតួអក្សរគ្រោះថ្នាក់ ហើយបន្ទុកទិន្នន័យបាត់ទៅវិញ។ ទោះជាយ៉ាងណាក៏ដោយ វិធីសាស្រ្តនេះផ្តល់នូវអារម្មណ៍មិនពិតនៃសុវត្ថិភាព។ តាមពិតទៅ អ្នកវាយប្រហារអាចរំលងតម្រងសាមញ្ញដូចជា stripchar ការប្រើ បន្ទុកដែលមិនច្បាស់លាស់ការអ៊ិនកូដ ឬការប្តូរបរិបទដ៏ឆ្លាតវៃ។ នោះហើយជាមូលហេតុដែលអ្នកអភិវឌ្ឍន៍ឆ្លាតវៃមិនឈប់ត្រឹមហ្នឹងទេ។ ផ្ទុយទៅវិញ ពួកគេប្រើ សំណួរដែលមានប៉ារ៉ាម៉ែត្រដែលការពារការវាយប្រហារដោយការចាក់នៅឫស។
នៅក្នុងអត្ថបទនេះ អ្នកនឹងរៀនពីមូលហេតុ stripchar បរាជ័យក្នុងសេណារីយ៉ូពិភពពិត របៀបដែលអ្នកវាយប្រហារប្រើប្រាស់តម្រងទាំងនេះខុស និងជម្រើសសុវត្ថិភាពអ្វីខ្លះដែលពិតជាដំណើរការ។ យើងនឹងពន្យល់ពីឧទាហរណ៍កូដ បង្ហាញបច្ចេកទេស bypass ទូទៅ និងពន្យល់ពីរបៀប ការបញ្ចូលអនាម័យ ត្រូវតែភ្ជាប់ជាមួយការការពាររចនាសម្ព័ន្ធដូចជា សំណួរដែលមានប៉ារ៉ាម៉ែត្រឬអ្នកនឹងនៅតែងាយរងគ្រោះ។
អ្វី stripchar ពិតជាធ្វើ (និងមិនមែន)
អ្នកអភិវឌ្ឍន៍ជាច្រើនប្រើប្រាស់ stripchar ឬមុខងារស្រដៀងគ្នាដើម្បីលុបតួអក្សរដែលមិនមានសុវត្ថិភាពចេញពីការបញ្ចូលរបស់អ្នកប្រើប្រាស់។ ជាធម្មតា វាលុបសញ្ញាវណ្ណយុត្តិ និមិត្តសញ្ញាពិសេស ឬអ្វីដែលមិនមែនជាអក្សរក្រមលេខ។ ដំបូងឡើយ វាស្តាប់ទៅដូចជា ការបញ្ចូលអនាម័យប៉ុន្តែវាមិនមែនជាការការពារពិតប្រាកដទេ។
ចូរយើងវិភាគវា។ អនុគមន៍ដូចនេះ៖
function stripchar(input) {
return input.replace(/[^\w\s]/gi, '');
}
លុបតួអក្សរដូចជា ', "ឬ ;ដូច្នេះប្រសិនបើអ្នកបញ្ចូល៖
'; DROP TABLE users; --
វាក្លាយជា៖
DROP TABLE users
ទោះបីជាការបញ្ចូលរបស់អ្នកប្រើប្រាស់មើលទៅស្អាតក៏ដោយ អ្នកវាយប្រហារនៅតែអាចចាក់បញ្ចូលទិន្នន័យ SQL ដោយប្រើតក្កវិជ្ជាតែម្នាក់ឯង ជាពិសេសនៅពេលដែលកម្មវិធីបង្កើតសំណួរតាមរយៈការភ្ជាប់ខ្សែអក្សរ។ ដើម្បីទប់ស្កាត់ការចាក់ SQL យ៉ាងពិតប្រាកដអ្នកត្រូវតែប្រើសំណួរដែលមានប៉ារ៉ាម៉ែត្រ និងការគ្រប់គ្រងការបញ្ចូលដែលដឹងអំពីបរិបទ។ តម្រងតួអក្សរដូចជា stripchar() គ្រាន់តែមិនគ្រប់គ្រាន់ទេ។
ពិតណាស់ ការបញ្ចូលដែលត្រូវបានដកចេញអាចមើលទៅមានសុវត្ថិភាពជាងនៅពេលមើលមួយភ្លែត។ ទោះជាយ៉ាងណាក៏ដោយ វិធីសាស្រ្តនេះមិនបន្សាបតក្កវិជ្ជាព្យាបាទទេ វាគ្រាន់តែផ្លាស់ប្តូររបៀបដែលវាត្រូវបានសរសេរប៉ុណ្ណោះ។ តាមពិតទៅ អ្នកវាយប្រហារច្រើនតែទាញយកអត្ថប្រយោជន៍ពីរឿងនេះដោយការអ៊ិនកូដបន្ទុកទិន្នន័យ បញ្ចូលចន្លោះទទេ ឬប្រើតួអក្សរដែលត្រូវបានដកចេញជាយុទ្ធសាស្ត្រដើម្បីរំលងតម្រងរបស់អ្នកទាំងស្រុង។
ក្រៅពីនេះ, stripchar ខ្វះបរិបទសំខាន់។ វាមិនដឹងថាតើការបញ្ចូលកំពុងឆ្ពោះទៅកាន់មូលដ្ឋានទិន្នន័យ សែល ឬកម្មវិធីរុករកតាមអ៊ីនធឺណិតទេ។ នោះមានន័យថាវាមិនអាចអនុវត្តការគេចចេញ ឬការអ៊ិនកូដត្រឹមត្រូវបានទេ។ ការសម្អាតការបញ្ចូលដោយមិនដឹងពីគោលដៅគឺដូចជាការគេចចេញពី HTML ខណៈពេលដែលការគំរាមកំហែងពិតប្រាកដគឺ SQLi.
នៅចុងបញ្ចប់, stripchar មិនបកស្រាយ ឬធានាសុវត្ថិភាពអ្វីទាំងអស់ វាគ្រាន់តែកែសម្រួលខ្សែអក្សរប៉ុណ្ណោះ។ ហើយការកែសម្រួលមិនមែនជាសុវត្ថិភាពទេ។ ប្រសិនបើអ្នកចង់បានការការពារពិតប្រាកដ សូមប្រើសំណួរដែលមានរចនាសម្ព័ន្ធ មានសុពលភាព និងកំណត់ប៉ារ៉ាម៉ែត្រ។ ចំណុចពេញលេញ។
ដើម្បីធ្វើឱ្យភាពខុសគ្នាកាន់តែច្បាស់ នេះជារបៀបដែល stripchar ប្រៀបធៀបជាមួយសំណួរដែលមានប៉ារ៉ាម៉ែត្រ៖
Stripchar ទល់នឹង Parameterized Queries៖ តើមួយណាពិតជាការពារកូដរបស់អ្នក?
| លក្ខណៈពិសេស | stripchar() | សំណួរដែលកំណត់ប៉ារ៉ាម៉ែត្រ |
|---|---|---|
| កម្រិតការការពារ | ការសម្អាតខ្សែអក្សរមូលដ្ឋាន។ ងាយស្រួលរំលងដោយប្រើល្បិចអ៊ិនកូដ ឬតក្កវិជ្ជា។ | ការការពារដ៏រឹងមាំប្រឆាំងនឹងការចាក់ SQL គ្រប់ទម្រង់។ |
| ការយល់ដឹងអំពីបរិបទ | មិនអើពើនឹងបរិបទ (SQL, HTML, shell ។ល។)។ អនុវត្តច្បាប់ដូចគ្នានៅគ្រប់ទីកន្លែង។ | យល់ដឹងពីបរិបទទាំងស្រុង។ ប្រើប្រាស់ការគេចចេញត្រឹមត្រូវសម្រាប់បរិស្ថាននីមួយៗ។ |
| កិច្ចខិតខំប្រឹងប្រែងរបស់អ្នកអភិវឌ្ឍន៍ | អនុវត្តបានរហ័ស ប៉ុន្តែមិនគួរទុកចិត្តសម្រាប់ការប្រើប្រាស់រយៈពេលវែង។ | តម្រូវឱ្យមានការធ្វើសមាហរណកម្មត្រឹមត្រូវ ប៉ុន្តែរឹងមាំ និងធន់នឹងអនាគត។ |
| ភាពធន់នឹងផ្លូវវាង | ទាប — អ្នកវាយប្រហារសម្របខ្លួនបានយ៉ាងងាយស្រួលដោយប្រើចន្លោះទទេ ការអ៊ិនកូដ ឬតក្កវិជ្ជា។ | ខ្ពស់ — បំបែកកូដចេញពីទិន្នន័យ និងរារាំងការចាក់បញ្ចូលបានយ៉ាងមានប្រសិទ្ធភាព។ |
| ទំនុកចិត្តលើសុវត្ថិភាព | អារម្មណ៍សុវត្ថិភាពមិនពិត — អាចលាក់បាំងបញ្ហាដោយមិនចាំបាច់ជួសជុលវា។ | ឧស្សាហកម្មដែលគួរឱ្យទុកចិត្ត standard សម្រាប់ការប្រតិបត្តិសំណួរដែលមានសុវត្ថិភាព។ |
របៀបដែលអ្នកវាយប្រហាររំលងការសម្អាតធាតុចូល
នេះជារបៀបដែលលំហូរងាយរងគ្រោះធម្មតាមើលទៅនៅពេលដែលអ្នកអភិវឌ្ឍន៍ពឹងផ្អែកលើ stripchar សម្រាប់ការសម្អាតធាតុចូល៖
អ្នកវាយប្រហារមិនចាំបាច់បំបែកតម្រងរបស់អ្នកទេ ពួកគេគ្រាន់តែត្រូវការ ទៅជុំវិញពួកគេនៅពេលដែលអ្នកអភិវឌ្ឍន៍ពឹងផ្អែកលើ stripchar សម្រាប់ការសម្អាតការបញ្ចូល ពួកគេច្រើនតែសន្មតថាការដកតួអក្សរដូចជាសញ្ញាសម្រង់ ឬសញ្ញាក្បៀសនឹងរារាំងការប៉ុនប៉ងបញ្ចូល។ ទោះជាយ៉ាងណាក៏ដោយ អ្នកវាយប្រហារសម្របខ្លួនបានយ៉ាងឆាប់រហ័ស។ ពួកគេបង្កើត បន្ទុកដែលមិនច្បាស់លាស់ ដែលរអិលឆ្លងកាត់តម្រងដែលមានមូលដ្ឋានលើ regex ជាពិសេសនៅពេលដែលតម្រងទាំងនោះខ្វះបរិបទ។
ឧទាហរណ៍ ឧបមាថាអ្នកព្យាយាមសម្អាតការបញ្ចូលដូចនេះ៖
const input = stripchar(userInput);
// safe to use? maybe not.
db.query("SELECT * FROM users WHERE name = '" + input + "'");
ទោះបីជាអ្នកប្រើប្រាស់មិនអាចដាក់ស្នើបុរាណបានក៏ដោយ ' OR 1=1 --ពួកគេអាចប្រើល្បិចយូនីកូដ ការភ្ជាប់ខ្សែអក្សរ ឬវាក្យសម្ព័ន្ធដែលខូចដែលនៅតែដំណើរការ។ បន្ទុកការងារដូចនេះច្រើនតែដំណើរការ៖
0x27206F7220313D31--
ឬ:
'+UNION+SELECT+null,null,null--
ប្រសិនបើអនុគមន៍របស់អ្នកដកតួអក្សរដែលមិនមែនជាពាក្យចេញ អ្នកអាច សាងសង់ឡើងវិញដោយចៃដន្យនូវពាក្យបញ្ជា SQL ដែលមានសុពលភាពអ្វីដែលអាក្រក់ជាងនេះទៅទៀត អ្នកវាយប្រហារអាចអ៊ិនកូដតម្លៃតាមរបៀបដែលឆ្លងកាត់តម្រងរបស់អ្នក ប៉ុន្តែត្រូវបានឌិគ្រីបដោយប្រព័ន្ធគោលដៅ។
ក្រៅពីការចាក់ SQL stripchar បរាជ័យក្នុងបរិបទផ្សេងទៀតដែរ ដូចជាពាក្យបញ្ជាសែល ផ្លូវឯកសារ ឬសូម្បីតែការប្រតិបត្តិ JavaScript។ ដោយសារវាខ្វះការយល់ដឹងអំពីកន្លែងដែលការបញ្ចូលនឹងត្រូវបានប្រើ វាមិនអាចអនុវត្តការគេចចេញ ឬការផ្ទៀងផ្ទាត់បានត្រឹមត្រូវទេ។
ជាលទ្ធផល, ការបញ្ចូលអនាម័យ ជាមួយ stripchar ងាយស្រួលរំលង។ សុវត្ថិភាពពិតប្រាកដកើតចេញពី ការគ្រប់គ្រងដែលដឹងអំពីបរិបទជាពិសេស។ សំណួរដែលមានប៉ារ៉ាម៉ែត្រ ដែលការពារការចាក់ឡូជីខលទាំងស្រុង។
ហេតុអ្វីបានជាអ្នកគួរប្រើ Parameterized Query ជំនួសវិញ
ប្រសិនបើអ្នកចង់បញ្ឈប់ការវាយប្រហារដោយការចាក់ថ្នាំពិតប្រាកដ អ្នកត្រូវ ឈប់បង្កើតសំណួរជាមួយខ្សែអក្សរ។ នោះហើយជាកន្លែង សំណួរដែលមានប៉ារ៉ាម៉ែត្រ ចូលមក។ មិនដូច stripcharពួកគេមិនត្រងទេ ពួកគេ បំបែកលេខកូដពីទិន្នន័យ នៅកម្រិតម៉ាស៊ីន។
ចូរយើងពិនិត្យមើលសំណួរដែលខូចឡើងវិញ៖
const input = stripchar(userInput);
const query = "SELECT * FROM users WHERE name = '" + input + "'";
នេះមានគ្រោះថ្នាក់ណាស់ ពីព្រោះការបញ្ចូលត្រូវបានចាក់ដោយផ្ទាល់ទៅក្នុង SQL។ សូម្បីតែជាមួយនឹងការដកតួអក្សរចេញក៏ដោយ អ្នកនៅតែកំពុងបង្កើតខ្សែអក្សរដែលអាចត្រូវបានគេប្រើប្រាស់ខុស។ ផ្ទុយទៅវិញ សូមប្រើសំណួរដែលមានប៉ារ៉ាម៉ែត្រដូចនេះ៖
const query = "SELECT * FROM users WHERE name = ?";
db.execute(query, [userInput]);
នៅទីនេះ កម្មវិធីបញ្ជាមូលដ្ឋានទិន្នន័យដឹងថា userInput គឺជាទិន្នន័យ កូដដែលមិនអាចប្រតិបត្តិបានវាគេចចេញពីវាដោយស្វ័យប្រវត្តិ ហើយរារាំងការចាក់បញ្ចូល ទោះបីជាការបញ្ចូលមានសញ្ញាសម្រង់ សញ្ញាក្បៀស ឬបន្ទុកដែលបានអ៊ិនកូដដោយ hex ក៏ដោយ។
នៅក្នុង Python៖
cursor.execute("SELECT * FROM users WHERE name = %s", (user_input,))
នៅក្នុង PHP ជាមួយ PDO៖
$stmt = $pdo->prepare("SELECT * FROM users WHERE name = :name");
$stmt->execute(['name' => $input]);
នៅទូទាំងឧទាហរណ៍ទាំងអស់នេះ សំណួរដែលមានប៉ារ៉ាម៉ែត្រ ការពារការចាក់ដោយមិនចាំបាច់ទាយថាតួអង្គណាដែលអាចមានគ្រោះថ្នាក់។ អ្នកមិនត្រូវការ ស្ទ្រីបឆា, អ្នកត្រូវការការកសាងសំណួរដែលមានរចនាសម្ព័ន្ធ និងយល់ដឹងពីបរិបទ។
លើសពីនេះ បច្ចេកទេសនេះរារាំង payloads ដែលមានភាពមិនច្បាស់លាស់ ល្បិច Unicode និងការរំលងការអ៊ិនកូដ ដែលជាគំរូគេចវេសដូចគ្នាដែលត្រូវបានរកឃើញនៅក្នុង ភាពងាយរងគ្រោះ XSSឧបករណ៍ដូចជា Xygeni ចាប់បានការគំរាមកំហែងទាំងនេះតាំងពីដំបូង SAST ការវិភាគ.
សរុបមក ការការពារពិតប្រាកដមិនពឹងផ្អែកលើតម្រងទេ។ ពួកវាពឹងផ្អែកលើពិធីការ API ដែលគួរឱ្យទុកចិត្ត និងបរិបទពេញលេញ។ ប្រសិនបើអ្នកប្រើក្របខ័ណ្ឌ ឬការចាក់បញ្ចូលសេវាកម្មថាមវន្ត សូមប្រយ័ត្នអំពីរបៀបដែលធាតុចូលរីករាលដាលតាមរយៈមូលដ្ឋានកូដរបស់អ្នក។ ការចាក់បញ្ចូលការពឹងផ្អែកដែលមានសុវត្ថិភាព ធានាថាសូម្បីតែលំហូរស្មុគស្មាញក៏មិនបើកផ្ទៃវាយប្រហារថ្មីដែរ។
កុំពឹងផ្អែកលើ stripcharប្រើ Xygeni ដើម្បីអនុវត្តការការពារពិតប្រាកដ
ទោះបីជាអ្នកប្រើ សំណួរដែលមានប៉ារ៉ាម៉ែត្រ, មិនមានការធានាថាមូលដ្ឋានកូដទាំងមូលរបស់អ្នកធ្វើតាមដូចគ្នានោះទេ standardតក្កវិជ្ជាចាស់ៗ ស្គ្រីបភាគីទីបី ឬបន្ទាត់ដែលត្រូវបានមើលរំលងនៅក្នុង PR នៅតែអាចបង្កឱ្យមានហានិភ័យនៃការចាក់បញ្ចូល។ នោះហើយជាកន្លែងដែល Xygeni ជួយ។
Xygeni ស្កេនកូដប្រភពរបស់អ្នក pull requestsនិង ស៊ី.អាយ. pipelines ដើម្បីចាប់៖
- ខ្សែអក្សរសំណួរដែលបង្កើត SQL ជាមួយនឹងការភ្ជាប់គ្នា
- តម្រងខ្សោយ ឬតម្រងផលិតនៅផ្ទះដូចជា stripchar
- តក្កវិជ្ជាគួរឱ្យសង្ស័យដែលត្រូវគ្នានឹងបន្ទុកព័ត៌មានដែលមិនច្បាស់លាស់ដែលគេស្គាល់
អ្នកមិនចាំបាច់រកមើលគ្រប់បន្ទាត់ទេ។ Xygeni សម្គាល់គំរូដែលមិនមានសុវត្ថិភាពជាមុន ហើយអាចអនុវត្តបាន ជួសជុលដោយស្វ័យប្រវត្តិ កន្លែងណាដែលអាចធ្វើទៅបាន ហើយអាចទប់ស្កាត់ការរួមបញ្ចូលគ្នាដែលមានហានិភ័យជាមួយនឹងការប្ដូរតាមបំណង Guardrails.
នៅក្នុងរយៈពេលខ្លី, Xygeni ធ្វើឱ្យប្រាកដថាសំណួរដែលមានប៉ារ៉ាម៉ែត្រមិនមែនគ្រាន់តែជាការអនុវត្តល្អបំផុតនោះទេ ពួកវាត្រូវបានអនុវត្តក្នុងទ្រង់ទ្រាយធំ។ លែងមានការស្មានទុកជាមុនទៀតហើយ។ គ្មានតម្រងដែលខកខានឡើយ។ គ្រាន់តែជាការការពារពិតប្រាកដប៉ុណ្ណោះ។
ចង់ឃើញពីរបៀបដែល Xygeni រកឃើញសំណួរដែលមិនមានសុវត្ថិភាពនៅក្នុងកូដរបស់អ្នក?
ចំណុចសំខាន់ៗ៖ អ្វីដែលត្រូវចងចាំអំពី stripchar និងហានិភ័យនៃការចាក់ថ្នាំ
- stripchar មិនមែនជាមុខងារសុវត្ថិភាពទេ — វាលុបតួអង្គចេញ មិនមែនហានិភ័យទេ។
- ការសម្អាតធាតុចូលមិនគ្រប់គ្រាន់ទេ នៅពេលអ្នកកំពុងបង្កើតសំណួរដោយប្រើការភ្ជាប់ខ្សែអក្សរ។
- សំណួរដែលមានប៉ារ៉ាម៉ែត្រគឺជាការការពារត្រឹមត្រូវហើយភាសា ឬក្របខណ្ឌទំនើបៗទាំងអស់គាំទ្រពួកវា។
- បន្ទុកដែលមិនច្បាស់លាស់អាចរអិលឆ្លងកាត់តម្រងបានជាពិសេសប្រសិនបើល្បិចអ៊ិនកូដត្រូវបានពាក់ព័ន្ធ។
- ការវិភាគឋិតិវន្ត (SAST) ឧបករណ៍ចាប់យកអ្វីដែលមនុស្សខកខានរួមទាំងលំនាំមិនមានសុវត្ថិភាពដែលលាក់ខ្លួននៅក្នុងកូដចាស់។
- Xygeni ធ្វើស្វ័យប្រវត្តិកម្មការរកឃើញ ការកំណត់អាទិភាព និងសូម្បីតែការកែតម្រូវ ដូច្នេះក្រុមរបស់អ្នកអាចផ្តោតលើការសរសេរលក្ខណៈពិសេស មិនមែនការដេញតាមចំណុចខ្សោយនោះទេ។
សេចក្តីសន្និដ្ឋាន៖ កុំទុកចិត្តតម្រង។ ធានាសុវត្ថិភាពតាមការរចនា។
ពឹងផ្អែកលើមុខងារដូចជា stripchar អាចមានអារម្មណ៍ថាជាការជួសជុលរហ័ស ប៉ុន្តែវាបង្កើតអារម្មណ៍សុវត្ថិភាពមិនពិត។ អ្នកវាយប្រហារវិវត្តលឿនជាងតម្រងខ្សែអក្សរ។ មធ្យោបាយដែលអាចទុកចិត្តបានតែមួយគត់ដើម្បីបញ្ឈប់ការវាយប្រហារដោយការចាក់បញ្ចូលគឺដោយការសរសេរកូដដែលមានសុវត្ថិភាពតាមការរចនា និងអនុវត្តការរចនានោះគ្រប់ទីកន្លែង។
ឧបករណ៍ដូចជា Xygeni ជួយអ្នកធ្វើដូច្នេះដោយស្វ័យប្រវត្តិ។ pull request ទៅ pipelineពួកវាចាប់អ្វីដែលតម្រងរបស់អ្នកមិនចាប់បាន ហើយជួសជុលវាមុនពេលវាឈានដល់ការផលិត។
