មូលប្បទានប័ត្រដែលខកខានដែលអាចធ្វើឱ្យអ្នកខាតបង់៖ ទម្រង់ស្នើសុំ Requests.get និង Flask
ស្រមៃមើលរឿងនេះ៖ អ្នកអភិវឌ្ឍន៍វ័យក្មេងម្នាក់កំពុងធ្វើការក្រោមសម្ពាធដើម្បីបញ្ជូនមុខងារមួយ។ ពួកគេបើកកម្មវិធី Flask បន្ថែមផ្លូវថ្មី ចាប់យកប៉ារ៉ាម៉ែត្រសំណួរ ហើយបន្តទៅមុខទៀត។
# Demonstrative example only — NOT executable, not exploitable
from flask import Flask, request
@app.route("/items")
def get_items():
# Type casting avoids unsafe string injection
item_id = request.args.get("id", type=int)
# Safe usage: forces integer input, prevents injection
នៅពេលក្រឡេកមើលដំបូង ការប្រើប្រាស់សំណើ Flask នេះមើលទៅល្អ។ ប៉ុន្តែត្រូវលុបចោល ប្រភេទ = int ហើយអ្នកបើកទ្វារទៅ ការវាយប្រហារដោយការចាក់ថ្នាំ។ ទាំងនេះគឺជាប្រភេទនៃហានិភ័យដែលរំលងការពិនិត្យកូដ ពីព្រោះ "វាគ្រាន់តែទាញយកតម្លៃប៉ុណ្ណោះ"។
កន្លែងដែលហានិភ័យលាក់ខ្លួននៅក្នុង Fសំណើសុំ lask និង Fទម្រង់ស្នើសុំឡាស
ទាំងពីរ សំណើសុំដប និង ទម្រង់បែបបទស្នើសុំដប គឺជាចំណុចចូលដែលមិនគួរឱ្យទុកចិត្ត។ តម្លៃនីមួយៗដែលពួកគេប្រគល់មកវិញ មកពីអតិថិជនដោយផ្ទាល់ ហើយគួរតែត្រូវបានចាត់ទុកថាជាអរិភាពដែលអាចកើតមាន។
ការបរាជ័យក្នុងការផ្ទៀងផ្ទាត់ ឬធ្វើឱ្យទិន្នន័យនេះស្អាតអាចនាំឱ្យមានបញ្ហាសុវត្ថិភាពធ្ងន់ធ្ងរ រួមមាន៖
ហានិភ័យទាំងនេះមិនត្រឹមតែអនុវត្តចំពោះមូលដ្ឋានទិន្នន័យ ឬការបង្ហាញផ្នែកខាងមុខប៉ុណ្ណោះទេ។ អ្នកវាយប្រហារក៏អាចកេងប្រវ័ញ្ចធាតុចូលដែលប្រើក្នុងគំរូ ឬបញ្ជូនទៅដំណើរការរងផងដែរ។
លំនាំកូដក្លែងក្លាយដែលមានសុវត្ថិភាព៖
python
# ⚠️ Educational example only — not functional
env_target = input("Enter deployment environment: ")
simulate_deploy(env_target) # Simulated for demonstration
ការការពារ CI/CD ការអនុវត្ត៖
# 1. Query parameter — Safe with casting
user_id = request.args.get("id", type=int) # Enforces integer type
# 2. Form parameter — Safe with casting
username = request.form.get("username", type=str) # Enforces string type
# 3. Template rendering safeguard
template_data = {"name": request.args.get("name", type=str)} # Avoids untrusted HTML injection
# 4. Shell command safe handling
filename = request.args.get("file", type=str)
# Validate filename against known safe values before use in subprocess (not shown)
ទោះបីជាវាក្យសម្ព័ន្ធមើលទៅមានសុវត្ថិភាពក៏ដោយ ការប្រើប្រាស់តម្លៃឆៅ ឬតម្លៃដែលមិនបានធីកនៅក្នុងគំរូ ឬពាក្យបញ្ជាប្រព័ន្ធអាចក្លាយជាវ៉ិចទ័រចាក់បញ្ចូលដ៏ធ្ងន់ធ្ងរ។
លំហូរចាក់ជាក់ស្តែង (ការក្លែងធ្វើដោយសុវត្ថិភាព)
នេះជារបៀបដែលកំហុសក្នុងការចាក់ជាធម្មតាលាតត្រដាង ដោយប្រើសេណារីយ៉ូប្រឌិត និងមានសុវត្ថិភាព៖
- អ្នកប្រើប្រាស់ផ្ញើប៉ារ៉ាម៉ែត្រសំណួរដែលបានបង្កើតទៅកម្មវិធី។
- កម្មវិធីនេះអានតម្លៃដោយប្រើ request.args.get() ដោយគ្មានការផ្ទៀងផ្ទាត់។
- តម្លៃនោះត្រូវបានភ្ជាប់ដោយផ្ទាល់ទៅក្នុងសំណួរ SQL ខ្សែអក្សរគំរូ ឬពាក្យបញ្ជាសែល។
- ប្រព័ន្ធនេះអនុវត្តតក្កវិជ្ជានោះ ដោយមិនដឹងអំពីខ្លឹមសារដែលបានចាក់ចូលនោះទេ។
កូដក្លែងក្លាយ (មិនមានសុវត្ថិភាព សម្រាប់តែឧទាហរណ៍ប៉ុណ្ណោះ)៖
# Insecure example — do not run in production
user_id = request.args.get("id") # Missing type casting, no validation
query = f"SELECT * FROM users WHERE id = {user_id}" # Risk of injection
ដានកំណត់ហេតុប្រឌិត៖
[INFO] Incoming request: /user?id=unexpected_input
[DEBUG] Parsed user_id: unexpected_input
[DEBUG] Constructed SQL: SELECT * FROM users WHERE id = unexpected_input
ទោះបីជាឧទាហរណ៍នេះប្រើកន្លែងដាក់សញ្ញាក្បៀសក៏ដោយ វាឆ្លុះបញ្ចាំងពីរបៀបដែលការមើលរំលងតិចតួចក្នុងការដោះស្រាយការបញ្ចូលអាចនាំឱ្យមានភាពងាយរងគ្រោះធ្ងន់ធ្ងរ។
ការធ្វើតេស្តដោយស្វ័យប្រវត្តិអាចនឹងខកខានចំណុចនេះ ពីព្រោះជាធម្មតាពួកវាសាកល្បងប្រភេទបញ្ចូលដែលមានសុពលភាព មិនមែនប្រភេទដែលមានទម្រង់ខុស ឬព្យាបាទនោះទេ។
ហានិភ័យលាក់កំបាំងក្នុងការពឹងផ្អែកដោយប្រើ សំណើសុំដប និង ទម្រង់ស្នើសុំដប
កូដរបស់អ្នកប្រហែលជាស្អាត ប៉ុន្តែកញ្ចប់ភាគីទីបីនៅតែអាចធ្វើឱ្យអ្នកខូចបាន។
កម្មវិធីជំនួយ ឬបណ្ណាល័យ Flask មួយចំនួនហៅសំណើ flask ឬទម្រង់សំណើ flask ជាលក្ខណៈផ្ទៃក្នុងដោយមិនចាំបាច់មានការផ្ទៀងផ្ទាត់។
ឧទាហរណ៍ជាមួយកញ្ចប់ប្រឌិត៖
python
# Insecure example — do not run in production
return AutoFormHandler.process() # May use request.form.get() without validation
python
# Insecure example — do not run in production
query = build_query(request.args) # May use request.args.get() without casting
In CI/CDការអាប់ដេតការពឹងផ្អែកដោយស្វ័យប្រវត្តិអាចណែនាំដោយស្ងៀមស្ងាត់នូវសំណើដែលមិនមានសុវត្ថិភាព។ ទទួលបានការហៅទូរសព្ទ ឬគំរូដោះស្រាយការបញ្ចូលដែលងាយរងគ្រោះ។
មិនមានសុវត្ថិភាពប៉ុណ្ណា សំណើសុំដប ការពិនិត្យឡើងវិញអំពីលេខកូដអតីតកាលនៃប័ណ្ណប្រើប្រាស់
នៅក្នុងបរិយាកាសដែលមានល្បឿនលឿន កំហុសតូចតាចប៉ុន្តែមានគ្រោះថ្នាក់ច្រើនតែមិនត្រូវបានគេកត់សម្គាល់ ជាពិសេសនៅពេលដែលការផ្លាស់ប្តូរហាក់ដូចជាគ្មានគ្រោះថ្នាក់។
ឧទាហរណ៍ pull request ភាពខុសគ្នា៖
# Insecure example — do not run in production
- user_id = request.args.get("id")
+ user_id = request.args.get("id") # Still missing type casting
មតិយោបល់របស់អ្នកវាយតម្លៃ៖
"មើលទៅល្អ វាគ្រាន់តែកំពុងទទួលបានប៉ារ៉ាម៉ែត្រមួយប៉ុណ្ណោះ"
ការធ្វេសប្រហែសប្រភេទនេះជារឿងធម្មតាដោយសារ៖
- ភាពលំអៀងនៃការយល់ដឹង: អ្នកពិនិត្យអាចសន្មតថា request.args.get() មានសុវត្ថិភាពតាមលំនាំដើម។
- សម្ពាធពេលវេលាការត្រួតពិនិត្យសន្តិសុខត្រូវបានលុបចោល នៅពេលដែលថ្ងៃផុតកំណត់ជិតមកដល់។
- ភាពខុសគ្នានៃការស្គាល់៖ ការផ្លាស់ប្ដូរមើលទៅដូចជាតូចតាច ដូច្នេះវាមិនត្រូវបានពិនិត្យយ៉ាងស៊ីជម្រៅទេ។
បើគ្មានច្បាប់ច្បាស់លាស់ ឬការអនុវត្តដោយស្វ័យប្រវត្តិទេ ហានិភ័យដ៏ស្រទន់ទាំងនេះរអិលចូលទៅក្នុងផលិតកម្មដោយមិនមាននរណាកត់សម្គាល់។
ការបង្ការដែលមានប្រសិទ្ធភាព
ដើម្បីកាត់បន្ថយហានិភ័យនៃការចាក់បញ្ចូល សូមផ្សំការផ្ទៀងផ្ទាត់ការបញ្ចូល ការស្កេនដោយស្វ័យប្រវត្តិ និងការគ្របដណ្តប់លើការធ្វើតេស្ត។
ការផ្ទៀងផ្ទាត់ការបញ្ចូលជាមួយនឹងការបញ្ជូន និងការដាក់ក្នុងបញ្ជីស៖
user_id = request.args.get("id", type=int)
if user_id not in [1, 2, 3]:
abort(400, "Invalid ID")
ការបញ្ជូនបង្ខំតម្លៃទៅជាប្រភេទដែលមានសុវត្ថិភាព ខណៈដែលការដាក់ក្នុងបញ្ជីសធានាថាមានតែតម្លៃដែលគេស្គាល់ល្អប៉ុណ្ណោះដែលដំណើរការ។
ការធ្វើតេស្តសុវត្ថិភាពកម្មវិធីឋិតិវន្ត (SAST) នៅ CI/CD:
name: Run SAST scan
run: sast-tool --scan src/ --fail-on "request.args.get without type"
ជំហាននេះជួយរកឃើញអ្វីដែលមិនទាន់មានសុពលភាព request.args.get() or request.form.get() ការហៅទូរស័ព្ទមុនពេលពួកគេឈានដល់ការផលិត។
ការធ្វើតេស្តឯកតាដើម្បីអនុវត្តអនាម័យ៖
def test_invalid_type(client):
response = client.get("/items?id=abc")
assert response.status_code == 400
These tests ensure the app rejects malformed or malicious input consistently.
Integrating Into DevSecOps Pipelines
Middleware enforcement:
@app.before_request
ការធ្វើតេស្តទាំងនេះធានាថាកម្មវិធីបដិសេធការបញ្ចូលដែលមានទម្រង់ខុស ឬមានគំនិតអាក្រក់ជាប់លាប់។
ការរួមបញ្ចូលទៅក្នុង DevSecOps Pipelines
ការអនុវត្តកម្មវិធីកណ្តាល៖
@កម្មវិធី.មុន_សំណើ
def sanitize_input():
if "id" in request.args and not request.args.get("id", type=int):
abort(400, "Invalid ID")
Pre-commit hook:
bash
if grep -R "request.args.get(" . | grep -v "type="; then
echo "Unsafe request.args.get detected — please add type casting."
exit 1
fi
កំពុងស្កេនទាំងកូដរបស់អ្នក និងការពឹងផ្អែករបស់ភាគីទីបី ជួយចាប់យកសំណើមិនមានសុវត្ថិភាព។ ទទួលបាន សំណើដប និងការប្រើប្រាស់ទម្រង់សំណើដប មុនពេលវាឈានដល់ការផលិត។
បញ្ហានេះលើសពីដប
ការដោះស្រាយការបញ្ចូលដែលមិនមានសុវត្ថិភាពមិនមែនមានចំពោះតែ Flask នោះទេ វាមាននៅទូទាំងក្របខ័ណ្ឌគេហទំព័រ។ ជាសំណាងល្អ ដំណោះស្រាយគឺស៊ីសង្វាក់គ្នា៖ ផ្ទៀងផ្ទាត់ការបញ្ចូលឱ្យបានឆាប់ និងយ៉ាងតឹងរ៉ឹង។
Django (កូដក្លែងក្លាយដែលមានសុវត្ថិភាព):
# Enforces integer type and applies whitelist
user_id = int(request.GET.get("id", "0"))
if user_id not in [1, 2, 3]:
return HttpResponseBadRequest()
FastAPI (មានសុវត្ថិភាពដោយការរចនាដោយប្រើការណែនាំអំពីប្រភេទ)៖
from fastapi import Query
@app.get("/items")
def read_items(id: int = Query(..., ge=1, le=3)):
return {"id": id}
ឧទាហរណ៍ទាំងពីរអនុវត្តប្រភេទ និងជួរបញ្ចូល ដោយធានាថាទិន្នន័យចូលត្រូវបានទុកចិត្តមុនពេលវាឈានដល់តក្កវិជ្ជារសើប។
មិនថាវាជា Flask, Django ឬ FastAPI ទេ ប៉ារ៉ាម៉ែត្រសំណើនីមួយៗគឺជាចំណុចចាក់បញ្ចូលដែលអាចកើតមាន ប្រសិនបើមិនត្រូវបានផ្ទៀងផ្ទាត់ឱ្យបានត្រឹមត្រូវ។
ការប្រើប្រាស់ Xygeni សម្រាប់ការរកឃើញនៅក្នុង DevSecOps
នៅក្នុងបរិយាកាស DevSecOps ការពិនិត្យដោយដៃមិនគ្រប់គ្រាន់ទេ។ ស៊ីហ្គេនី ស្វ័យប្រវត្តិកម្មការរកឃើញសំណើសុំដបទឹកដែលមិនមានសុវត្ថិភាព ទម្រង់ស្នើសុំដបទឹក និងការប្រើប្រាស់សំណើ។ ទទួលបាន។
កម្មវិធី DevSecOps ជាក់ស្តែង៖
- ការស្កេនឋិតិវន្ត: ទង់ជាតិណាមួយ request.args.get() ដោយគ្មាន ប្រភេទ =និងការហៅទម្រង់បែបបទស្នើសុំដបដែលខ្វះសុពលភាព។
- ការវិភាគភាពអាស្រ័យ៖ ត្រួតពិនិត្យបណ្ណាល័យសម្រាប់លំនាំមិនមានសុវត្ថិភាពដែលអាចលេចឡើងតាមរយៈការហៅដោយប្រយោល។
- ការទប់ស្កាត់ការរួមបញ្ចូលគ្នាដែលមិនមានសុវត្ថិភាព: CI/CD បរាជ័យប្រសិនបើកូដថ្មីណែនាំសំណើដែលមានហានិភ័យ។ ទទួលបាន ឬការចូលប្រើទម្រង់ដែលមិនបានផ្ទៀងផ្ទាត់។
- ការអនុវត្តមូលដ្ឋាន៖ តាមដានការផ្លាស់ប្តូរ ដើម្បីការពារការហៅទូរសព្ទដែលមានសុវត្ថិភាពពីការធ្លាក់ចូលទៅក្នុងការហៅទូរសព្ទដែលមិនមានសុវត្ថិភាព។
ការធ្វើស្វ័យប្រវត្តិកម្មការត្រួតពិនិត្យទាំងនេះកាត់បន្ថយហានិភ័យនៃកំហុសរបស់មនុស្ស និង រក្សាសុវត្ថិភាពជាបន្តបន្ទាប់ដោយមិនធ្វើឱ្យការដឹកជញ្ជូនយឺត។
ដូច្នេះ ផ្ទៀងផ្ទាត់ ធ្វើអនាម័យ ធ្វើស្វ័យប្រវត្តិកម្ម
នេះជាចំណុចសំខាន់៖ requests.get, flask request និង flask request form សុទ្ធតែជា... មិនគួរឱ្យទុកចិត្តតាមលំនាំដើមពួកគេនឹងរីករាយក្នុងការផ្តល់ទិន្នន័យព្យាបាទ លុះត្រាតែអ្នកចាត់វិធានការ។
ច្បាប់ទាំងបីរបស់អ្នក៖
- ធ្វើឱ្យមានសុពលភាព ការបញ្ចូលដោយប្រើការបញ្ជូន និងបញ្ជីស។
- ធ្វើអនាម័យ មុនពេលទិន្នន័យប៉ះនឹងប្រតិបត្តិការដ៏រសើប។
- ស្វ័យប្រវត្តិ ការត្រួតពិនិត្យនៅក្នុងរបស់អ្នក pipeline ដើម្បីបញ្ឈប់កូដដែលមិនមានសុវត្ថិភាពមុនពេលដាក់ពង្រាយ។
កម្មវិធីដោះស្រាយសំណើ flask តែមួយដែលមិនមានសុវត្ថិភាព វាលបែបបទសំណើ flask ដែលមិនបានធីក ឬការហៅ requests.get ដែលមិនបានការពារអាចធ្វើឱ្យកម្មវិធីរបស់អ្នកខូច។ ចាត់ទុកប៉ារ៉ាម៉ែត្រនីមួយៗថាជាអរិភាពដែលអាចកើតមាន ហើយអនុញ្ញាតឱ្យ DevSecOps របស់អ្នក... pipeline អនុវត្តច្បាប់រាល់ពេល។
