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