តើ Dosfuscation ជាអ្វី? ហេតុអ្វីបានជាអ្នកអភិវឌ្ឍន៍គួរយកចិត្តទុកដាក់
នេះជារូបភាពសង្ខេបអំពីការគំរាមកំហែង៖ ស្រមៃមើលការពិនិត្យមើល PR ដែលមើលទៅដូចជាការអាប់ដេតឧបករណ៍ប្រើប្រាស់តូចមួយ។ នៅខាងក្នុង អ្នករួមចំណែកម្នាក់បានបន្ថែមអ្វីដែលហាក់ដូចជាស្គ្រីបជំនួយដែលគ្មានគ្រោះថ្នាក់។ ប៉ុន្តែនៅពេលបញ្ចូលគ្នា វាដំណើរការក្នុងអំឡុងពេល CI។ pipeline ហើយបង្កឲ្យមានរង្វិលជុំមួយដែលប្រើប្រាស់អង្គចងចាំទាំងអស់ដោយស្ងាត់ៗ ដែលធ្វើឲ្យការសាងសង់គាំង។
Dosfuscation គឺជាប្រភេទនៃការវាយប្រហារបដិសេធសេវាកម្មផ្ទៃក្នុង (DoS) ដែលក្លែងបន្លំដោយប្រើបច្ចេកទេសបំភាន់កូដ។ វារួមបញ្ចូលគ្នានូវតក្កវិជ្ជាដែលត្រូវបានរចនាឡើងដើម្បីបំបែកការប្រតិបត្តិ ដូចជារង្វិលជុំគ្មានកំណត់ ឬការរីកធំនៃអង្គចងចាំ ជាមួយនឹងយុទ្ធសាស្ត្រដែលលាក់ឥរិយាបថពិតរបស់វា ដែលធ្វើឱ្យវាពិបាកក្នុងការរកឃើញក្នុងអំឡុងពេលពិនិត្យ ឬសវនកម្ម។ នេះមិនមែនជាការវាយប្រហារពីខាងក្រៅទេ វាស្ថិតនៅក្នុងកូដរបស់អ្នករួចហើយ រង់ចាំការបំផ្ទុះដំណើរការសាងសង់ ឬផលិតកម្មរបស់អ្នក។
ហេតុអ្វីត្រូវខ្វល់? មិនដូចការវាយប្រហារបែបប្រពៃណីនៃការបដិសេធសេវាកម្មដែលជន់លិចម៉ាស៊ីនមេរបស់អ្នកជាមួយនឹងចរាចរណ៍នោះទេ ការបិទសេវាកម្មលាក់ខ្លួននៅកន្លែងដែលអាចមើលឃើញយ៉ាងច្បាស់ ជារឿយៗឆ្លងកាត់ការពិនិត្យកូដ ឬការត្រួតពិនិត្យកញ្ចប់។ វាគឺជាគ្រាប់បែកឡូជីខលដែលត្រូវបានដុតចូលទៅក្នុង... pipeline.
ឧទាហរណ៍ជាក់ស្តែង៖ An កញ្ចប់ npm មានរង្វិលជុំគ្មានកំណត់ដែលក្លែងបន្លំ។ វាឆ្លងកាត់ការដំឡើងបានល្អ ប៉ុន្តែប្រើប្រាស់អង្គចងចាំយ៉ាងច្រើនក្នុងផលិតកម្មរហូតដល់កម្មវិធីរបស់អ្នកគាំង។ នេះបង្ហាញពីរបៀបដែល dosfuscation ដែលដំណើរការដោយបច្ចេកទេស obfuscation ក្លាយជាបំរែបំរួលលាក់បាំងនៃការវាយប្រហារបដិសេធសេវាកម្មប្រភេទដែលបង្កគ្រោះថ្នាក់បំផុត។
ភាពខុសគ្នាពិតប្រាកដនៃហានិភ័យរវាង DoS និង Dosfuscation
ការវាយប្រហារបែបបដិសេធសេវាកម្ម (Dosfuscation) គឺជាប្រភេទរងនៃការវាយប្រហារបែបបដិសេធសេវាកម្ម។ វាខុសពីការវាយប្រហារបែបប្រពៃណីបែបបដិសេធសេវាកម្ម ដោយប្រតិបត្តិតាមរយៈកូដដែលលាក់បាំង មិនមែនចរាចរណ៍បណ្តាញទេ។
ស្រមៃមើល៖ អ្នកអនុម័ត PR នៅក្នុង GitHub។ ការធ្វើតេស្តឆ្លងកាត់ ការបង្កើតចាប់ផ្តើម បន្ទាប់មកអ្នករត់របស់អ្នកគាំង។ អ្នកកំពុងបំបាត់កំហុសការងារ GitHub Actions ដែលបរាជ័យ ដែលតែងតែអស់ពេល។ វាប្រែថា payload ដែលមិនបានបំពេញតាមតម្រូវការក្នុងភាពអាស្រ័យតិចតួចបានណែនាំរង្វិលជុំគ្មានកំណត់នៅក្នុងស្គ្រីបក្រោយការដំឡើង។
នៅពេលដែលអ្នកអភិវឌ្ឍន៍គិតអំពីការបដិសេធសេវាកម្ម ជាធម្មតាពួកគេស្រមៃមើលសេណារីយ៉ូពីខាងក្រៅ ដូចជាហ្វូងសំណើព្យាបាទដែលវាយប្រហារ API ឬ botnet ដែលធ្វើឱ្យអស់ bandwidth។ ទាំងនេះគឺជាប្រភេទបុរាណនៃការវាយប្រហារបដិសេធសេវាកម្ម ហើយយើងភាគច្រើនបានត្រៀមខ្លួនរួចរាល់សម្រាប់ពួកគេ។ យើងមាន WAFs នៅនឹងកន្លែង អនុវត្តការកំណត់អត្រា និងបង្កើតហេដ្ឋារចនាសម្ព័ន្ធដែលអាចធ្វើមាត្រដ្ឋានបាន ដែលអាចស្រូបយកការវាយប្រហារ។
ទោះជាយ៉ាងណាក៏ដោយ ការប្រើប្រាស់ Dosfuscation មិនមែនមកពីខាងក្រៅទេ។ វាត្រូវបានភ្ជាប់ដោយផ្ទាល់ទៅក្នុងមូលដ្ឋានកូដរបស់អ្នក។ វាលាក់ខ្លួននៅក្នុង dependencies ហើយលួចចូលតាមរយៈ CI។ pipelines ហើយរង់ចាំរហូតដល់ការប្រតិបត្តិដើម្បីបំផ្ទុះអ្វីៗ។ គ្មានការលៃតម្រូវជញ្ជាំងភ្លើង ឬកម្រិតណាទេ ការកាត់បន្ថយ DDoS នឹងបញ្ឈប់វា ពីព្រោះវាមិនដែលធ្វើដំណើរលើបណ្តាញទេ។ វាមាននៅផ្ទះរួចហើយ។
នេះធ្វើឱ្យ dosfuscation ក្លាយជាទម្រង់លាក់លៀមនៃការបដិសេធសេវាកម្ម។ វាមិនប្រកាសខ្លួនឯងជាមួយនឹងសំឡេងរំខានបណ្តាញទេ។ វាសម្លាប់ពីខាងក្នុង នៅពេលបង្កើត អំឡុងពេលដំណើរការ ឬនៅពេលដែលសាខាឡូជីខលជាក់លាក់មួយត្រូវបានវាយប្រហារ។ ហើយដោយសារតែវាត្រូវបានកប់នៅក្នុងកូដដោយប្រើបច្ចេកទេសបិទបាំងកម្រិតខ្ពស់ អ្នកនឹងមិនអាចចាប់វាបានទេ លុះត្រាតែអ្នកកំពុងរកមើលឱ្យស៊ីជម្រៅ។
នោះហើយជាមូលហេតុដែល ក្រុម DevSecOps ត្រូវគិតហួសពីការការពារបរិវេណ។ សុវត្ថិភាពស្រទាប់កម្មវិធីក៏សំខាន់ដូចគ្នាដែរ។ ប្រសិនបើការផ្តោតអារម្មណ៍តែមួយគត់របស់អ្នកគឺលើការទប់ស្កាត់ចរាចរណ៍មិនល្អ អ្នកនឹងខកខានបន្ទុកទិន្នន័យដែលមានស្រាប់នៅក្នុង repo របស់អ្នក។
របៀបដែលអ្នកវាយប្រហារប្រើប្រាស់ការបិទបាំងដើម្បីលាក់តក្កវិជ្ជា DoS នៅក្នុងកូដ
អ្នកប្រហែលជាឃើញរឿងនេះកើតឡើងនៅពេលដែលការងារលំហូរការងារចាប់ផ្តើមចំណាយពេលយូរជាងការរំពឹងទុក ឬអាក្រក់ជាងនេះទៅទៀត មិនដែលបញ្ចប់។ ឧទាហរណ៍មួយពាក់ព័ន្ធនឹងក្រុមមួយដែលកំពុងដំណើរការការធ្វើតេស្តនៅក្នុងកុងតឺន័រ Docker តាមរយៈ សកម្មភាព GitHub។ ជំនួយការសាកល្បង JavaScript តូចមួយត្រូវបានបន្ថែមតាមរយៈម៉ូឌុលភាគីទីបី។ វាត្រូវបានបិទបាំងដើម្បីបិទបាំងរង្វិលជុំបែងចែកអង្គចងចាំគ្មានកំណត់ ដែលធ្វើឱ្យដំណើរការណូតមិនឆ្លើយតប។
បន្ទុកទិន្នន័យ DoS ដែលបិទបាំងជារឿយៗរអិលចេញដោយមិនមាននរណាកត់សម្គាល់នៅក្នុងលំហូរការងារ CI។ ឧទាហរណ៍ សកម្មភាព GitHub pipeline អាចដំណើរការស្គ្រីបដែលហាក់ដូចជាគ្មានគ្រោះថ្នាក់ ដែលភ្លាមៗនោះគាំងការងារដោយសារតែរង្វិលជុំគ្មានកំណត់ដែលបានបង្កប់។
ដើម្បីធ្វើឱ្យរឿងនេះក្លាយជាការពិត នេះជាអ្វីដែល payload ដែលត្រូវបានដាក់ឱ្យដំណើរការអាចមើលទៅដូចនៅក្នុងកូដប្រចាំថ្ងៃ។
ឧទាហរណ៍ JavaScript៖ រង្វិលជុំគ្មានកំណត់ដែលលាក់
វាបំពេញអង្គចងចាំដោយគ្មានកំណត់ដោយប្រើតក្កវិជ្ជាក្លែងបន្លំ ដែលនៅទីបំផុតធ្វើឱ្យកម្មវិធីគាំង។
ឧទាហរណ៍ Python៖ CPU Hog ដែលត្រូវបានបិទបាំង
import base64
exec(base64.b64decode("d2hpbGUgVHJ1ZToKICBhcCA9IFtdCiAgZm9yIGkgaW4gcmFuZ2UoMTAwMDAwMDApOgogICAgYXAucHVzaChzdHIoaSkp"))
រង្វិលជុំដែលបានអ៊ិនកូដជាមូលដ្ឋាន 64 នេះដំណើរការឥតឈប់ឈរ ដោយប្រើប្រាស់អង្គចងចាំយ៉ាងច្រើនដោយមិនមើលទៅគួរឲ្យសង្ស័យនៅពេលមើលដំបូងឡើយ។
កន្លែងដែលបន្ទុកបន្ទុកលាក់ខ្លួន៖ សេណារីយ៉ូនៃការបំភាន់ក្នុងពិភពពិត
បន្ទុកផ្ទុកទិន្នន័យដែលមិនបានត្រួតពិនិត្យច្រើនតែលាក់ខ្លួននៅកន្លែងដែលអាចមើលឃើញយ៉ាងច្បាស់ នៅក្នុងកញ្ចប់ភាគីទីបី ជាប្រភពបើកចំហ។ pull requestsឬស្គ្រីបខាងក្នុងត្រូវបានប្រើឡើងវិញដោយគ្មានការត្រួតពិនិត្យ។ អ្នកវាយប្រហារពឹងផ្អែកលើល្បឿនអភិវឌ្ឍន៍ និងស្វ័យប្រវត្តិកម្មដើម្បីលួចចូលដោយមិនមាននរណាកត់សម្គាល់ ដែលបង្កប់គ្រាប់បែកតក្កវិជ្ជាយ៉ាងជ្រៅនៅក្នុងរបស់អ្នក pipeline.
សេណារីយ៉ូពិភពលោកពិតជួយបង្ហាញពីរបៀបដែលរឿងនេះកើតឡើង៖
អ្នកកំពុងប្រើ GitHub Actions ដើម្បីដំណើរការលំហូរការងារ CI របស់អ្នក។ របស់អ្នក .github/workflows/build.yml ដំឡើងការពឹងផ្អែកលើគម្រោង។ មួយក្នុងចំណោមនោះគឺកញ្ចប់ npm អន្តរកាល ដែលត្រូវបានដំឡើងមិនមែនដោយអ្នកដោយផ្ទាល់ទេ ប៉ុន្តែជាការពឹងផ្អែកនៃការពឹងផ្អែក។ វាអះអាងថាជួយជាមួយអ្វីដែលមិនសំខាន់ ដូចជាការរៀបចំខ្សែអក្សរ។
ប៉ុន្តែនៅខាងក្នុងកញ្ចប់ ដែលលាក់ដោយប្រើបច្ចេកទេសបិទបាំង គឺជាគ្រាប់បែកឡូជីខល។ វាអាចជារង្វិលជុំបែងចែកអង្គចងចាំគ្មានកំណត់ដែលបង្កឡើងក្នុងអំឡុងពេល ក្រោយការដំឡើង ស្គ្រីប ឬការនាំចូលពេលដំណើរការនៅក្នុងការធ្វើតេស្តរបស់អ្នក។ វានៅតែអសកម្មរហូតដល់ការប្រតិបត្តិ គ្មានការព្រមាន គ្មានទង់សវនកម្ម។
ភ្លាមៗនោះ ឧបករណ៍ដំណើរការ CI របស់អ្នកគាំង។ CPU និងអង្គចងចាំកើនឡើងខ្ពស់។ ការងារត្រូវអស់ពេល។ ការបង្កើត ឬការដាក់ពង្រាយរបស់អ្នកបរាជ័យ។
នេះមិនមែនគ្រាន់តែជាសម្មតិកម្មនោះទេ។ ឧប្បត្តិហេតុដូចនេះត្រូវបានគេសង្កេតឃើញនៅក្នុងធម្មជាតិ។ ពួកវាបង្ហាញពីរបៀបដែល dosfuscation ទាញយកអត្ថប្រយោជន៍ពីទំនុកចិត្តនៅក្នុង toolchain របស់អ្នក ការកេងប្រវ័ញ្ចលំហូរការងារដោយស្វ័យប្រវត្តិ ការរួមបញ្ចូលគ្នាលឿន និងការពឹងផ្អែកដោយប្រយោល។
តើបន្ទុកផ្ទុកទាំងនេះជាធម្មតាលាក់ខ្លួននៅកន្លែងណា?
- កញ្ចប់ភាគីទីបី៖ ជាពិសេសពី npm, PyPI ឬ Maven។
- PR ប្រភពបើកចំហ៖ ជាមួយនឹងតក្កវិជ្ជាលួចលាក់ដែលបិទបាំងជាការអាប់ដេតដែលមានប្រយោជន៍។
- ស្គ្រីបខាងក្នុង៖ បំណែកអត្ថបទដែលបានប្រើឡើងវិញដោយគ្មានការផ្ទៀងផ្ទាត់ ឬការពិនិត្យត្រឹមត្រូវ។
អ្នកវាយប្រហារប្រើប្រាស់ការបិទបាំងដើម្បីពន្យារពេលការរកឃើញ ដោយពឹងផ្អែកលើការពិនិត្យកូដរាក់ៗ និងការអាប់ដេតភាពអាស្រ័យដោយស្វ័យប្រវត្តិដើម្បីធ្វើអ្វីដែលនៅសល់។
របៀបរកឃើញ Dosfuscation នៅក្នុងកូដ និងការពឹងផ្អែករបស់អ្នក
ប្រើការវិភាគឋិតិវន្តដើម្បីស្វែងរកតក្កវិជ្ជាចម្លែក
ប្រើឧបករណ៍ដែល៖
- រកឃើញបច្ចេកទេសបិទបាំងដូចជាលំហូរត្រួតពិនិត្យដែលច្របល់ចូលគ្នា ឬការកសាងខ្សែអក្សរឡើងវិញ។
- សម្គាល់តក្កវិជ្ជាដែលស្មុគស្មាញពេកសម្រាប់ម៉ូឌុលសាមញ្ញ។
- បន្លិចមុខងារ ឬគំរូស្គ្រីបដែលស្រដៀងនឹងប្រភេទនៃការវាយប្រហារបដិសេធសេវាកម្ម។
ស្កេនភាពអាស្រ័យជាមួយនឹងច្រើនជាងការត្រួតពិនិត្យកំណែ
កុំឈប់តែពិនិត្យមើលលេខកំណែ៖
- សូមមើលនៅខាងក្នុងលេខកូដពិតប្រាកដ។
- ផ្តល់អាទិភាពដល់ការពិនិត្យឡើងវិញនូវការអាប់ដេតកញ្ចប់ថ្មីៗ។
- ស្វែងរកខ្សែអក្សរដែលបានអ៊ិនកូដ តក្កវិជ្ជាដែលលាក់ ឬសញ្ញាសម្គាល់ Dosfuscation។
ពិនិត្យមើលដោយដៃនូវអ្វីដែលគួរឱ្យសង្ស័យ Pull Requests
មើលសម្រាប់៖
- ការផ្លាស់ប្តូរស្មុគស្មាញពេកនៅក្នុងការអាប់ដេតសាមញ្ញ។
- តក្កវិជ្ជាមិនច្បាស់លាស់ ឬមិនអាចអានបាននៅក្នុងកូដថ្មី។
- ទំនាក់ទំនងសាធារណៈណែនាំបច្ចេកទេសលាក់បាំងដែលគេស្គាល់។
ការមិនអើពើនឹងរឿងនេះកើតឡើងនៅពេលដែលមនុស្សគ្រប់គ្នាសន្មតថា «វាគ្រាន់តែជាការផ្លាស់ប្តូរតិចតួចប៉ុណ្ណោះ»។
វិធីការពារកុំឱ្យ Dosfuscation វាយប្រហារអ្នក CI/CD
នៅក្នុងបរិស្ថាន CI ដូចជា GitHub Actions, GitLab CI ឬ CircleCI ការបង្ការគឺនិយាយអំពីការរៀបចំការគ្រប់គ្រងដែលរកឃើញ និងរារាំង payloads ដែលលាក់បាំងតាំងពីដំបូង។ ឧទាហរណ៍ អនុវត្តការពិនិត្យ PR សម្រាប់លំហូរការងារទាំងអស់ដែលមានស្គ្រីបសែល ឬដំឡើង hooksនិងតាមដាន .yml pipeline ការកំណត់រចនាសម្ព័ន្ធសម្រាប់សកម្មភាពភាគីទីបីដែលមិនទាន់បានផ្ទៀងផ្ទាត់។
CI/CD គឺជាទីលានលេងសម្រាប់លេងល្បែងកម្សាន្ត។ នេះជារបៀបចាក់សោវា៖
- បន្ថែមម៉ាស៊ីនស្កេនឋិតិវន្តទៅ PR នីមួយៗ ហើយបង្កើត។
- ប្រើតែកញ្ចប់ពីប្រភពដែលគួរឱ្យទុកចិត្ត និងបានផ្ទៀងផ្ទាត់។
- តាមដានការប្រើប្រាស់ធនធានបង្កើត; ការកើនឡើងខ្ពស់អាចមានន័យថាតក្កវិជ្ជាដែលលាក់កំបាំង។
- ផ្គូផ្គងរាល់ការពឹងផ្អែកទល់នឹងការធីក SBOM.
- ហាមឃាត់ការប្រើប្រាស់បច្ចេកទេសបំភាន់ទូទៅដោយគ្មានហេតុផលជាឯកសារ។
លែងមាន «ការដំឡើង និងសង្ឃឹម» ទៀតហើយ។ ការបង្ការមានន័យថាមាន guardrails បានបង្កើតឡើងនៅក្នុងលំហូរការងាររបស់អ្នក។ ការចាប់បាន dosfuscation តាំងពីដំបូងការពារការវាយប្រហារបដិសេធសេវាកម្មប្រភេទដែលរំខានបំផុត។
តួនាទីរបស់ Xygeni៖ ចាប់ Dosfuscation មុនពេលវាឈានដល់ការផលិត
ស៊ីហ្គេនី ជួយក្រុម DevSecOps បញ្ឈប់ការខ្ជះខ្ជាយពេលវេលាមុនពេលវាបណ្តាលឱ្យមានពេលវេលារងចាំដោយការបង្កប់ភាពវៃឆ្លាតសុវត្ថិភាពនៅទូទាំង លំហូរការងារអភិវឌ្ឍន៍វាមានជំនាញក្នុងការរកឃើញបច្ចេកទេសបំភាន់ និងអនុវត្តច្បាប់ដោយផ្អែកលើគោលនយោបាយ guardrails ដែលរារាំងការវាយប្រហារបដិសេធសេវាកម្មដោយលួចលាក់ពីការទៅដល់ផលិតកម្ម។
នៅក្នុងការពិនិត្យឡើងវិញអំពី PR
Xygeni ស្កេនកូដឌីផេរ៉ង់ស្យែលដើម្បីកំណត់សញ្ញានៃការបិទបាំងដូចជា៖
- ការប្រើប្រាស់នៃ ការគេចចេញ ឬវិធីសាស្ត្រប្រតិបត្តិថាមវន្តស្រដៀងគ្នា។
- ខ្សែអក្សរ Base64 ឬ hex-encoded ដែលមានន័យថាលាក់តក្កវិជ្ជា។
- លំហូរត្រួតពិនិត្យគួរឱ្យសង្ស័យ ដូចជារង្វិលជុំមិនធម្មតា ឬការបែកខ្ញែកតក្កវិជ្ជាស្មុគស្មាញ។
លំនាំទាំងនេះបង្កឱ្យមានការជូនដំណឹងតាមពេលវេលាជាក់ស្តែងក្នុងអំឡុងពេល pull request ការពិនិត្យឡើងវិញ ទាំងនៅក្នុងកូដភាគីទីមួយ ឬភាគីទីបី ដែលជួយអ្នកពិនិត្យសុវត្ថិភាពឱ្យរកឃើញកំហុសឆ្គងបានទាន់ពេលវេលា។
អំឡុងពេលវិភាគការពឹងផ្អែក
Xygeni មិនត្រឹមតែវិភាគទិន្នន័យមេតាកញ្ចប់ប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងប្រភពពិតប្រាកដនៃភាពអាស្រ័យថ្មី ឬដែលបានធ្វើបច្ចុប្បន្នភាពផងដែរ។ វារកឃើញតក្កវិជ្ជាដែលមិនច្បាស់លាស់ដែលបានបង្កប់នៅក្នុងមុខងារជំនួយ ឬស្គ្រីបក្រោយការដំឡើង ដោយសម្គាល់កញ្ចប់ដែលមានហានិភ័យខ្ពស់ ទោះបីជាពួកវាលេចឡើងស្របច្បាប់នៅលើផ្ទៃក៏ដោយ។
នៅពេលវេលាសាងសង់ក្នុង CI/CD Pipelines
Xygeni ត្រួតពិនិត្យការងារ CI សម្រាប់ភាពមិនប្រក្រតីនៃឥរិយាបថ។ ប្រសិនបើការបង្កើតមួយស្រាប់តែប្រើប្រាស់ CPU ឬអង្គចងចាំមិនធម្មតា Xygeni តាមដានការកើនឡើងនេះទៅកាន់កូដជាក់លាក់ ឬកញ្ចប់ដែលបានណែនាំថ្មីៗនេះ។ វាភ្ជាប់ទំនាក់ទំនងដោយស្វ័យប្រវត្តិនូវឥរិយាបថពេលដំណើរការជាមួយនឹងការរកឃើញឋិតិវន្ត ដើម្បីចាប់បន្ទុក DoS ដែលលាក់មុនពេលពួកវារំខានដល់ការចែកចាយ។
ក្នុងនាមជាស្រទាប់អនុវត្តគោលនយោបាយ
អ្នកអាចកំណត់រចនាសម្ព័ន្ធ Xygeni ដើម្បីរារាំងគំរូដែលមានហានិភ័យទាំងស្រុង ដូចជា៖
- ហាមឃាត់ការពឹងផ្អែកដែលរួមបញ្ចូលកូដដែលបានអ៊ិនកូដ base64 ឬ ការគេចចេញ
- តម្រូវឱ្យមានការអនុម័តដោយដៃសម្រាប់ស្គ្រីបក្រោយការដំឡើងទាំងអស់
- ការអនុវត្តច្បាប់មិនអត់ឱនចំពោះលំហូរត្រួតពិនិត្យដែលមិនច្បាស់លាស់នៅក្នុងការងារ PRs ឬ CI
ជាមួយ Xygeni សន្តិសុខក្លាយជាសកម្ម។ វាផ្តល់ឱ្យក្រុមនូវភាពមើលឃើញ ការព្រមានដំបូង និងការអនុវត្តកម្រិតគោលនយោបាយប្រឆាំងនឹងប្រភេទនៃបច្ចេកទេសបិទបាំងដែល dosfuscation ពឹងផ្អែក។ តាមរយៈការបង្កប់ Xygeni នៅក្នុងគ្រប់ដំណាក់កាល PRs ការស្កេនអាស្រ័យ និងពេលវេលាដំណើរការ CI អ្នកចាប់បានការគំរាមកំហែងមុនពេលវាក្លាយជាការស្លាប់ក្រោយការស្លាប់។
ដូច្នេះ Dosfuscation បង្វែរកូដរបស់អ្នកប្រឆាំងនឹងអ្នក
ការបំផ្លើសមិនមែនគ្រាន់តែជាហានិភ័យទ្រឹស្តីនោះទេ វាគឺជាវ៉ិចទ័រវាយប្រហារពិតប្រាកដ និងកំពុងកើនឡើង ដែលប្រែក្លាយដំណើរការអភិវឌ្ឍន៍របស់អ្នកទៅជាអាវុធ។ វារីកចម្រើននៅក្នុងគម្លាតរវាងការចេញផ្សាយយ៉ាងឆាប់រហ័ស ការដំឡើងដោយស្វ័យប្រវត្តិ និងខ្សែសង្វាក់អាស្រ័យដែលស្មុគស្មាញពេកក្នុងការធ្វើសវនកម្មដោយដៃ។ នេះមិនមែនគ្រាន់តែជាបញ្ហាសុវត្ថិភាពនោះទេ វាជាបញ្ហាប្រឈមផ្នែកវិស្វកម្មកម្មវិធី។ បន្ទុកទិន្នន័យបដិសេធសេវាកម្មដែលមិនច្បាស់លាស់ រំលងការការពារបែបប្រពៃណីដោយបង្កប់ខ្លួនវាដោយផ្ទាល់នៅក្នុងកូដ ដែលជញ្ជាំងភ្លើង និងតម្រងចរាចរណ៍មិនអាចទៅដល់។
សម្រាប់អ្នកអភិវឌ្ឍន៍ ចំណុចសំខាន់ៗគឺសាមញ្ញណាស់៖ ប្រសិនបើអ្នកសរសេរកូដ សូមយល់ព្រម pull requestsឬគ្រប់គ្រង CI/CD pipelineអ្នកគឺជាជួរមុខ។ ការបង្កើតដែលមានសុវត្ថិភាពមិនមែនគ្រាន់តែជាកូដស្អាតនោះទេ។ ពួកវាទាមទារភាពមើលឃើញ ការត្រួតពិនិត្យ និងការការពារដែលគាំទ្រដោយគោលនយោបាយនៅគ្រប់ជំហាននៃ pipeline.
ផ្លាស់ទីហួសពីបញ្ជីត្រួតពិនិត្យ។ រួមបញ្ចូលការរកឃើញការបិទបាំងទៅក្នុងលំហូរការងាររបស់អ្នក។ ប្រយ័ត្នចំពោះខ្សែអក្សរ base64 តក្កវិជ្ជាចម្លែក ឬការកើនឡើងដែលមិននឹកស្មានដល់នៅក្នុងការប្រើប្រាស់ធនធាន CI។ ផ្ទៀងផ្ទាត់មិនត្រឹមតែ អ្វី អ្នកដំឡើង ប៉ុន្តែ តើវាធ្វើអ្វី. ព្យាបាល pipeline ការកំណត់រចនាសម្ព័ន្ធដូចជាកូដផលិតកម្ម។ ស្វ័យប្រវត្តិកម្ម guardrailsសម្គាល់អ្វីដែលមើលទៅចម្លែក ទោះបីជាវា "ដំណើរការ" ក៏ដោយ។
ពីព្រោះការមិនស្វែងរកចម្លើយមិនស្រែកហៅទេ។ វារង់ចាំ។ ហើយប្រសិនបើអ្នកមិនកំពុងស្វែងរកវាទេ វានឹងរអិលចេញទៅ។
