ਇੱਕ ਖੁੰਝਿਆ ਹੋਇਆ ਚੈੱਕ ਜੋ ਤੁਹਾਨੂੰ ਮਹਿੰਗਾ ਪੈ ਸਕਦਾ ਹੈ: Requests.get ਅਤੇ 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 ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ, ਇਹ ਫਲਾਸਕ ਬੇਨਤੀ ਵਰਤੋਂ ਠੀਕ ਲੱਗਦੀ ਹੈ। ਪਰ ਛੱਡ ਦਿਓ ਟਾਈਪ=ਇੰਟ ਅਤੇ ਤੁਸੀਂ ਦਰਵਾਜ਼ਾ ਖੋਲ੍ਹਦੇ ਹੋ ਟੀਕੇ ਦੇ ਹਮਲੇ। ਇਹ ਉਹ ਕਿਸਮ ਦੇ ਜੋਖਮ ਹਨ ਜੋ ਕੋਡ ਸਮੀਖਿਆਵਾਂ ਤੋਂ ਪਿੱਛੇ ਹਟ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ "ਇਹ ਸਿਰਫ਼ ਇੱਕ ਮੁੱਲ ਲਿਆ ਰਿਹਾ ਹੈ।"
ਜਿੱਥੇ ਜੋਖਮ ਛੁਪਿਆ ਹੋਇਆ ਹੈ Fਲਾਸਕ ਬੇਨਤੀ ਅਤੇ Fਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ
ਦੋਨੋ ਫਲਾਸਕ.ਰਿਕਵੈਸਟ ਅਤੇ ਫਲਾਸਕ.ਰਿਕਵੈਸਟ.ਫਾਰਮ ਇਹ ਭਰੋਸੇਯੋਗ ਨਹੀਂ ਹਨ। ਉਹਨਾਂ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਹਰ ਮੁੱਲ ਸਿੱਧਾ ਕਲਾਇੰਟ ਤੋਂ ਆਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਵਿਰੋਧੀ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
ਇਸ ਡੇਟਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਜਾਂ ਸੈਨੀਟਾਈਜ਼ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਰਹਿਣ ਨਾਲ ਗੰਭੀਰ ਸੁਰੱਖਿਆ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
- SQL ਇਨਜੈਕਸ਼ਨ
- ਕਰਾਸ-ਸਾਈਟ ਸਕ੍ਰਿਪਟਿੰਗ (XSS)
- ਟੈਂਪਲੇਟ ਇੰਜੈਕਸ਼ਨ
- ਸ਼ੈੱਲ ਕਮਾਂਡ ਇੰਜੈਕਸ਼ਨ
ਇਹ ਜੋਖਮ ਸਿਰਫ਼ ਡੇਟਾਬੇਸ ਜਾਂ ਫਰੰਟ-ਐਂਡ ਰੈਂਡਰਿੰਗ 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਹੁੰਦੇ; ਹਮਲਾਵਰ ਟੈਂਪਲੇਟਾਂ ਵਿੱਚ ਵਰਤੇ ਗਏ ਜਾਂ ਸਬ-ਪ੍ਰੋਸੈਸਾਂ ਨੂੰ ਭੇਜੇ ਗਏ ਇਨਪੁਟਸ ਦਾ ਵੀ ਸ਼ੋਸ਼ਣ ਕਰ ਸਕਦੇ ਹਨ।
ਸੁਰੱਖਿਅਤ ਸੂਡੋ-ਕੋਡ ਪੈਟਰਨ:
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) ਭਾਵੇਂ ਸੰਟੈਕਸ ਸੁਰੱਖਿਅਤ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਟੈਂਪਲੇਟਾਂ ਜਾਂ ਸਿਸਟਮ ਕਮਾਂਡਾਂ ਵਿੱਚ ਕੱਚੇ ਜਾਂ ਅਣਚੈੱਕ ਕੀਤੇ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇੱਕ ਗੰਭੀਰ ਇੰਜੈਕਸ਼ਨ ਵੈਕਟਰ ਬਣ ਸਕਦਾ ਹੈ।
ਪ੍ਰੈਕਟੀਕਲ ਇੰਜੈਕਸ਼ਨ ਫਲੋ (ਸੁਰੱਖਿਅਤ ਸਿਮੂਲੇਸ਼ਨ)
ਇੱਕ ਕਾਲਪਨਿਕ, ਸੁਰੱਖਿਅਤ ਦ੍ਰਿਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਥੇ ਇੱਕ ਟੀਕੇ ਦੀ ਖਰਾਬੀ ਆਮ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਪ੍ਰਗਟ ਹੁੰਦੀ ਹੈ:
- ਇੱਕ ਉਪਭੋਗਤਾ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਤਿਆਰ ਕੀਤਾ ਪੁੱਛਗਿੱਛ ਪੈਰਾਮੀਟਰ ਭੇਜਦਾ ਹੈ।
- ਐਪ ਇਸਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁੱਲ ਪੜ੍ਹਦਾ ਹੈ ਬੇਨਤੀ.ਆਰਗਸ.ਗੈੱਟ() ਬਿਨਾਂ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ।
- ਉਹ ਮੁੱਲ ਸਿੱਧੇ ਇੱਕ 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 
ਭਾਵੇਂ ਇਹ ਉਦਾਹਰਣ ਪਲੇਸਹੋਲਡਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਇਹ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਇਨਪੁਟ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਛੋਟੀਆਂ ਗਲਤੀਆਂ ਕਿਵੇਂ ਗੰਭੀਰ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀਆਂ ਹਨ।
ਆਟੋਮੇਟਿਡ ਟੈਸਟ ਇਸ ਤੋਂ ਖੁੰਝ ਸਕਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਵੈਧ ਇਨਪੁਟ ਕਿਸਮਾਂ ਲਈ ਟੈਸਟ ਕਰਦੇ ਹਨ, ਨਾ ਕਿ ਨੁਕਸਦਾਰ ਜਾਂ ਖਤਰਨਾਕ ਕਿਸਮਾਂ ਲਈ।
ਨਿਰਭਰਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਵਿੱਚ ਲੁਕਵੇਂ ਜੋਖਮ ਫਲਾਸਕ ਬੇਨਤੀ ਅਤੇ ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ
ਤੁਹਾਡਾ ਕੋਡ ਸਾਫ਼ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਤੀਜੀ-ਧਿਰ ਦੇ ਪੈਕੇਜ ਅਜੇ ਵੀ ਤੁਹਾਨੂੰ ਤੋੜ ਸਕਦੇ ਹਨ।
ਕੁਝ ਫਲਾਸਕ ਪਲੱਗਇਨ ਜਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਫਲਾਸਕ ਬੇਨਤੀ ਜਾਂ ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ ਨੂੰ ਬਿਨਾਂ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ ਕਾਲ ਕਰਦੀਆਂ ਹਨ।
ਕਾਲਪਨਿਕ ਪੈਕੇਜਾਂ ਵਾਲੀ ਉਦਾਹਰਣ:
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" ਇਹ ਕਦਮ ਅਣ-ਪ੍ਰਮਾਣਿਤ ਦਾ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਬੇਨਤੀ.ਆਰਗਸ.ਗੈੱਟ() or ਬੇਨਤੀ.ਫਾਰਮ.ਗੈੱਟ() ਉਤਪਾਦਨ 'ਤੇ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲਾਂ।
ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ:
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 ਤੁਹਾਡੇ ਕੋਡ ਅਤੇ ਤੀਜੀ-ਧਿਰ ਨਿਰਭਰਤਾਵਾਂ ਦੋਵਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨਾ ਉਤਪਾਦਨ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਅਸੁਰੱਖਿਅਤ ਬੇਨਤੀਆਂ.get, ਫਲਾਸਕ ਬੇਨਤੀ, ਅਤੇ ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ ਦੀ ਵਰਤੋਂ ਨੂੰ ਫੜਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
ਇਹ ਸਮੱਸਿਆ ਫਲਾਸਕ ਤੋਂ ਪਰੇ ਜਾਂਦੀ ਹੈ
ਅਸੁਰੱਖਿਅਤ ਇਨਪੁੱਟ ਹੈਂਡਲਿੰਗ ਸਿਰਫ਼ ਫਲਾਸਕ ਲਈ ਹੀ ਨਹੀਂ ਹੈ, ਇਹ ਵੈੱਬ ਫਰੇਮਵਰਕ ਵਿੱਚ ਮੌਜੂਦ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਹੱਲ ਇਕਸਾਰ ਹੈ: ਇਨਪੁੱਟ ਨੂੰ ਜਲਦੀ ਅਤੇ ਸਖਤੀ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕਰੋ।
ਜੈਂਗੋ (ਸੁਰੱਖਿਅਤ ਸੂਡੋ-ਕੋਡ):
# 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} ਦੋਵੇਂ ਉਦਾਹਰਣਾਂ ਇਨਪੁਟ ਕਿਸਮ ਅਤੇ ਰੇਂਜ ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਕਿ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਸੰਵੇਦਨਸ਼ੀਲ ਤਰਕ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਭਰੋਸੇਯੋਗ ਬਣਾਇਆ ਜਾਵੇ।
ਭਾਵੇਂ ਇਹ ਫਲਾਸਕ, ਜੈਂਗੋ, ਜਾਂ ਫਾਸਟਏਪੀਆਈ ਹੋਵੇ, ਹਰੇਕ ਬੇਨਤੀ ਪੈਰਾਮੀਟਰ ਇੱਕ ਸੰਭਾਵੀ ਇੰਜੈਕਸ਼ਨ ਪੁਆਇੰਟ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।
DevSecOps ਵਿੱਚ ਖੋਜ ਲਈ Xygeni ਦੀ ਵਰਤੋਂ ਕਰਨਾ
DevSecOps ਵਾਤਾਵਰਣ ਵਿੱਚ, ਹੱਥੀਂ ਸਮੀਖਿਆਵਾਂ ਕਾਫ਼ੀ ਨਹੀਂ ਹਨ। ਜ਼ਾਇਗੇਨੀ ਅਸੁਰੱਖਿਅਤ ਫਲਾਸਕ ਬੇਨਤੀ, ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ, ਅਤੇ requests.get ਵਰਤੋਂ ਦੀ ਖੋਜ ਨੂੰ ਸਵੈਚਾਲਿਤ ਕਰਦਾ ਹੈ।
ਵਿਹਾਰਕ DevSecOps ਐਪਲੀਕੇਸ਼ਨ:
- ਸਥਿਰ ਸਕੈਨ: ਕਿਸੇ ਵੀ ਨੂੰ ਫਲੈਗ ਕਰੋ ਬੇਨਤੀ.ਆਰਗਸ.ਗੈੱਟ() ਬਿਨਾ ਕਿਸਮ=, ਅਤੇ ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ ਕਾਲਾਂ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਘਾਟ ਹੈ।
- ਨਿਰਭਰਤਾ ਵਿਸ਼ਲੇਸ਼ਣ: ਅਸੁਰੱਖਿਅਤ ਪੈਟਰਨਾਂ ਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ ਜੋ ਅਸਿੱਧੇ ਕਾਲਾਂ ਰਾਹੀਂ ਸਾਹਮਣੇ ਆ ਸਕਦੇ ਹਨ।
- ਅਸੁਰੱਖਿਅਤ ਮਰਜ ਨੂੰ ਬਲੌਕ ਕਰਨਾ: CI/CD ਜੇਕਰ ਨਵਾਂ ਕੋਡ ਜੋਖਮ ਭਰੇ requests.get ਜਾਂ ਅਣ-ਪ੍ਰਮਾਣਿਤ ਫਾਰਮ ਪਹੁੰਚ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਤਾਂ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ।
- ਮੁੱਢਲੀ ਪਾਲਣਾ: ਕਾਲਾਂ ਨੂੰ ਅਸੁਰੱਖਿਅਤ ਕਾਲਾਂ ਵਿੱਚ ਵਾਪਸ ਜਾਣ ਤੋਂ ਬਚਾਉਣ ਲਈ ਬਦਲਾਵਾਂ ਨੂੰ ਟਰੈਕ ਕਰਦਾ ਹੈ।
ਇਹਨਾਂ ਜਾਂਚਾਂ ਨੂੰ ਸਵੈਚਾਲਿਤ ਕਰਨ ਨਾਲ ਮਨੁੱਖੀ ਗਲਤੀ ਦਾ ਜੋਖਮ ਘੱਟ ਜਾਂਦਾ ਹੈ ਅਤੇ ਡਿਲੀਵਰੀ ਨੂੰ ਹੌਲੀ ਕੀਤੇ ਬਿਨਾਂ ਸੁਰੱਖਿਆ ਨੂੰ ਨਿਰੰਤਰ ਰੱਖਦਾ ਹੈ।
ਇਸ ਲਈ, ਪ੍ਰਮਾਣਿਤ ਕਰੋ, ਰੋਗਾਣੂ-ਮੁਕਤ ਕਰੋ, ਸਵੈਚਾਲਿਤ ਕਰੋ
ਇਹ ਹੈ ਮੁੱਖ ਗੱਲ: requests.get, flask request, ਅਤੇ flask request form ਸਾਰੇ ਹਨ ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ ਭਰੋਸੇਯੋਗ ਨਹੀਂ. ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਕਾਰਵਾਈ ਨਹੀਂ ਕਰਦੇ, ਉਹ ਖੁਸ਼ੀ ਨਾਲ ਖਤਰਨਾਕ ਡੇਟਾ ਪ੍ਰਦਾਨ ਕਰਨਗੇ।
ਤੁਹਾਡੇ ਤਿੰਨ ਨਿਯਮ:
- ਪੜਤਾਲ ਕਾਸਟਿੰਗ ਅਤੇ ਵਾਈਟਲਿਸਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਨਪੁਟਸ।
- ਸੈਨੀਟਾਈਜ਼ ਕਰੋ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਡੇਟਾ ਸੰਵੇਦਨਸ਼ੀਲ ਕਾਰਜਾਂ ਨੂੰ ਛੂਹ ਲਵੇ।
- ਸਵੈਚਾਲਤ ਤੁਹਾਡੀ ਜਾਂਚ ਕਰਦਾ ਹੈ pipeline ਤੈਨਾਤੀ ਤੋਂ ਪਹਿਲਾਂ ਅਸੁਰੱਖਿਅਤ ਕੋਡ ਨੂੰ ਰੋਕਣ ਲਈ।
ਇੱਕ ਸਿੰਗਲ ਅਸੁਰੱਖਿਅਤ ਫਲਾਸਕ ਬੇਨਤੀ ਹੈਂਡਲਰ, ਇੱਕ ਅਣਚੈਕ ਕੀਤਾ ਫਲਾਸਕ ਬੇਨਤੀ ਫਾਰਮ ਖੇਤਰ, ਜਾਂ ਇੱਕ ਅਣ-ਰੱਖਿਅਤ requests.get ਕਾਲ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨਾਲ ਸਮਝੌਤਾ ਕਰ ਸਕਦੀ ਹੈ। ਹਰੇਕ ਪੈਰਾਮੀਟਰ ਨੂੰ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਵਿਰੋਧੀ ਸਮਝੋ, ਅਤੇ ਆਪਣੇ DevSecOps ਨੂੰ pipeline ਹਰ ਵਾਰ ਨਿਯਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ।
