ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಅನ್ವೇಷಿಸಿ, ಪೈಥಾನ್‌ಗಾಗಿ ಪ್ರಬಲ ಸುರಕ್ಷತಾ ಲಿಂಟಿಂಗ್ ಸಾಧನ. ಸಾಮಾನ್ಯ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಹೇಗೆ ಪತ್ತೆ ಮಾಡುವುದು, ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳನ್ನು ಹೇಗೆ ಅಳವಡಿಸುವುದು ಮತ್ತು ನಿಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಒಟ್ಟಾರೆ ಸುರಕ್ಷತಾ ಭಂಗಿಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸುವುದು ಎಂಬುದನ್ನು ತಿಳಿಯಿರಿ.
ಬ್ಯಾಂಡಿಟ್ ಸುರಕ್ಷತಾ ಲಿಂಟಿಂಗ್: ಪೈಥಾನ್ ಸುರಕ್ಷತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ತಗ್ಗಿಸುವುದು
ಇಂದಿನ ಸಂಕೀರ್ಣ ಸೈಬರ್‌ ಸುರಕ್ಷತಾ ಭೂದೃಶ್ಯದಲ್ಲಿ, ಪೂರ್ವಭಾವಿ ಸುರಕ್ಷತಾ ಕ್ರಮಗಳು ಅತ್ಯುನ್ನತವಾಗಿವೆ. ಪೈಥಾನ್ ಅದರ ಬಹುಮುಖತೆ ಮತ್ತು ಬಳಕೆಯ ಸುಲಭತೆಗಾಗಿ ಹೆಸರುವಾಸಿಯಾಗಿದೆ, ಇದು ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಜನಪ್ರಿಯ ಆಯ್ಕೆಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಂತೆ, ಪೈಥಾನ್ ಕೋಡ್ ಸುರಕ್ಷತಾ ದೌರ್ಬಲ್ಯಗಳಿಗೆ ಒಳಗಾಗಬಹುದು. ಬ್ಯಾಂಡಿಟ್ ಇಲ್ಲಿಗೆ ಬರುತ್ತದೆ - ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿನ ಸಂಭಾವ್ಯ ಸುರಕ್ಷತಾ ದೋಷಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಗುರುತಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಪ್ರಬಲ ಸುರಕ್ಷತಾ ಲಿಂಟಿಂಗ್ ಸಾಧನ.
ಬ್ಯಾಂಡಿಟ್ ಎಂದರೇನು?
ಬ್ಯಾಂಡಿಟ್ ಎಂಬುದು ಪೈಥಾನ್‌ಗಾಗಿ ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಓಪನ್-ಸೋರ್ಸ್ ಭದ್ರತಾ ಲಿಂಟರ್ ಆಗಿದೆ. ಇದು ಸಾಮಾನ್ಯ ಭದ್ರತಾ ಸಮಸ್ಯೆಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಸಂಭಾವ್ಯ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಲು ಸಮಗ್ರವಾದ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಇದನ್ನು ಸ್ಥಿರ ವಿಶ್ಲೇಷಣಾ ಸಾಧನವೆಂದು ಯೋಚಿಸಿ, ಇದು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಬಳಸಿಕೊಳ್ಳುವ ಮೊದಲು, ಅಭಿವೃದ್ಧಿ ಜೀವನ ಚಕ್ರದ ಆರಂಭದಲ್ಲಿ ಸುರಕ್ಷತಾ ಸಮಸ್ಯೆಗಳನ್ನು ಹಿಡಿಯಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಬ್ಯಾಂಡಿಟ್ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ (AST) ಅನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಂತರ, ಇದು AST ಗೆ ತಿಳಿದಿರುವ ದೌರ್ಬಲ್ಯ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಸರಣಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ. ಸಂಭಾವ್ಯ ಸುರಕ್ಷತಾ ಸಮಸ್ಯೆಯನ್ನು ಕಂಡುಕೊಂಡಾಗ, ಬ್ಯಾಂಡಿಟ್ ಅದನ್ನು ತೀವ್ರತೆ ಮಟ್ಟ, ವಿಶ್ವಾಸಾರ್ಹತೆ ಮಟ್ಟ ಮತ್ತು ಸಮಸ್ಯೆಯ ವಿವರವಾದ ವಿವರಣೆಯೊಂದಿಗೆ ವರದಿ ಮಾಡುತ್ತದೆ.
ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಏಕೆ ಬಳಸುವುದು?
ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವಿಗೆ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದರಿಂದ ಹಲವಾರು ಗಮನಾರ್ಹ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ:
- ಆರಂಭಿಕ ದೌರ್ಬಲ್ಯ ಪತ್ತೆ: ಬ್ಯಾಂಡಿಟ್ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ನಂತರ ಅವುಗಳನ್ನು ಸರಿಪಡಿಸಲು ಅಗತ್ಯವಿರುವ ವೆಚ್ಚ ಮತ್ತು ಪ್ರಯತ್ನವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ಸುಧಾರಿತ ಕೋಡ್ ಗುಣಮಟ್ಟ: ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವ ಮೂಲಕ, ಬ್ಯಾಂಡಿಟ್ ಒಟ್ಟಾರೆ ಕೋಡ್ ಗುಣಮಟ್ಟ ಮತ್ತು ನಿರ್ವಹಣೆಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತದೆ.
- ಸ್ವಯಂಚಾಲಿತ ಭದ್ರತಾ ಆಡಿಟ್‌ಗಳು: ಬ್ಯಾಂಡಿಟ್ ಭದ್ರತಾ ಆಡಿಟಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಕೋಡ್ ಭದ್ರತಾ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
- OWASP ಟಾಪ್ 10 ಕವರೇಜ್: OWASP ಟಾಪ್ 10 ರಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾದ ಅನೇಕ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಬ್ಯಾಂಡಿಟ್ ಒಳಗೊಂಡಿದೆ, ಇದು ಸಾಮಾನ್ಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಭದ್ರತಾ ಅಪಾಯಗಳಿಂದ ನಿಮ್ಮನ್ನು ರಕ್ಷಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ನಿಯಮಗಳು: ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಭದ್ರತಾ ಅವಶ್ಯಕತೆಗಳು ಮತ್ತು ಕೋಡಿಂಗ್ ಮಾನದಂಡಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವಂತೆ ನೀವು ಬ್ಯಾಂಡಿಟ್‌ನ ನಿಯಮಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು.
- CI/CD ಪೈಪ್‌ಲೈನ್‌ಗಳೊಂದಿಗೆ ಏಕೀಕರಣ: ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ನಿಮ್ಮ ನಿರಂತರ ಏಕೀಕರಣ/ನಿರಂತರ ನಿಯೋಜನೆ (CI/CD) ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು, ಇದು ಪ್ರತಿ ಕೋಡ್ ಬದಲಾವಣೆಯಲ್ಲಿ ಭದ್ರತಾ ಪರಿಶೀಲನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಬ್ಯಾಂಡಿಟ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು ಹೇಗೆ
ಬ್ಯಾಂಡಿಟ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿ ಇಲ್ಲಿದೆ:
1. ಸ್ಥಾಪನೆ
ನೀವು ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪಕವಾದ ಪಿಪ್ ಬಳಸಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬಹುದು:
pip install bandit
2. ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು
ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಚಲಾಯಿಸಲು, ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:
bandit -r
<directory> ಅನ್ನು ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿಯೊಂದಿಗೆ ಬದಲಾಯಿಸಿ. -r ಫ್ಲ್ಯಾಗ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಪೈಥಾನ್ ಫೈಲ್‌ಗಳನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಬ್ಯಾಂಡಿಟ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ.
ನೀವು ಪ್ರತ್ಯೇಕ ಫೈಲ್‌ಗಳನ್ನು ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:
bandit
3. ಫಲಿತಾಂಶಗಳನ್ನು ಅರ್ಥೈಸುವುದು
ಬ್ಯಾಂಡಿಟ್ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಕಂಡುಬರುವ ಯಾವುದೇ ಸಂಭಾವ್ಯ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ವಿವರಿಸುವ ವರದಿಯನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ದೌರ್ಬಲ್ಯವನ್ನು ತೀವ್ರತೆ ಮಟ್ಟ (ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚು, ಮಧ್ಯಮ, ಕಡಿಮೆ) ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆ ಮಟ್ಟ (ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚು, ಮಧ್ಯಮ, ಕಡಿಮೆ) ಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ. ವರದಿಯು ದೌರ್ಬಲ್ಯದ ವಿವರವಾದ ವಿವರಣೆ ಮತ್ತು ಅದನ್ನು ಕಂಡುಹಿಡಿದ ಕೋಡ್‌ನ ಸಾಲನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ.
ಉದಾಹರಣೆ ಬ್ಯಾಂಡಿಟ್ ಔಟ್‌ಪುಟ್:
./example.py:10:0:B603 [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
Severity: High Confidence: High
Location: ./example.py:10
--------------------------------------------------
ಈ ಔಟ್‌ಪುಟ್ ಬ್ಯಾಂಡಿಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಹೆಚ್ಚಿನ-ತೀವ್ರತೆಯ ದೌರ್ಬಲ್ಯವನ್ನು ಕಂಡುಹಿಡಿದಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ example.py ಸಾಲು 10 ರಲ್ಲಿ. ದುರ್ಬಲತೆಯು subprocess.Popen ಅನ್ನು shell=True ನೊಂದಿಗೆ ಬಳಸುವುದಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ, ಇದು ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗಳಿಗೆ ಒಳಗಾಗುವ ಸಾಧ್ಯತೆಯಿದೆ ಎಂದು ತಿಳಿದುಬಂದಿದೆ.
ಬ್ಯಾಂಡಿಟ್‌ನಿಂದ ಪತ್ತೆ ಮಾಡಲಾದ ಸಾಮಾನ್ಯ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳು
ಬ್ಯಾಂಡಿಟ್ ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಾಮಾನ್ಯ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಪತ್ತೆ ಮಾಡಬಹುದು. ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:
- ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ (B602, B603): ಅವಿಶ್ವಾಸಾರ್ಹ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ
subprocess.Popenಅಥವಾos.systemಅನ್ನು ಬಳಸುವುದು ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. - SQL ಇಂಜೆಕ್ಷನ್ (B608): ಬಳಕೆದಾರರು ಒದಗಿಸಿದ ಡೇಟಾದೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಸೇರ್ಪಡೆಯನ್ನು ಬಳಸಿ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುವುದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು SQL ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗೆ ಒಡ್ಡಬಹುದು.
- ಹಾರ್ಡ್‌ಕೋಡೆಡ್ ಪಾಸ್‌ವರ್ಡ್‌ಗಳು (B105): ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಪಾಸ್‌ವರ್ಡ್‌ಗಳನ್ನು ನೇರವಾಗಿ ಸಂಗ್ರಹಿಸುವುದು ದೊಡ್ಡ ಭದ್ರತಾ ಅಪಾಯವಾಗಿದೆ.
- ದುರ್ಬಲ ಕ್ರಿಪ್ಟೋಗ್ರಫಿ (B303, B304, B322): ದುರ್ಬಲ ಅಥವಾ ಹಳೆಯ ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುವುದು ನಿಮ್ಮ ಡೇಟಾದ ಗೌಪ್ಯತೆ ಮತ್ತು ಸಮಗ್ರತೆಯನ್ನು ರಾಜಿ ಮಾಡಿಕೊಳ್ಳಬಹುದು.
- ಅಸುರಕ್ಷಿತ ಡೀಸೀರಿಯಲೈಸೇಶನ್ (B301, B401): ಅವಿಶ್ವಾಸಾರ್ಹ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಡೀಸೀರಿಯಲೈಸ್ ಮಾಡುವುದು ಅನಿಯಂತ್ರಿತ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾಗಬಹುದು.
- XML ಬಾಹ್ಯ ಎಂಟಿಟಿ (XXE) ಇಂಜೆಕ್ಷನ್ (B405): ಸರಿಯಾದ ನೈರ್ಮಲ್ಯವಿಲ್ಲದೆ ಅವಿಶ್ವಾಸಾರ್ಹ ಮೂಲಗಳಿಂದ XML ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು XXE ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗೆ ಒಡ್ಡಬಹುದು.
- ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ ದೌರ್ಬಲ್ಯಗಳು (B323): ಸರಿಯಾದ ನೈರ್ಮಲ್ಯವಿಲ್ಲದೆ ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ ಬಳಕೆದಾರರು ಒದಗಿಸಿದ ಡೇಟಾವನ್ನು ಬಳಸುವುದು ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ ದೌರ್ಬಲ್ಯಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
- `eval()` ಅಥವಾ `exec()` ಅನ್ನು ಬಳಸುವುದು (B301): ಈ ಕಾರ್ಯಗಳು ಅನಿಯಂತ್ರಿತ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ ಮತ್ತು ಅವಿಶ್ವಾಸಾರ್ಹ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಅವುಗಳನ್ನು ಬಳಸುವುದು ಅತ್ಯಂತ ಅಪಾಯಕಾರಿಯಾಗಿದೆ.
- ಅಸುರಕ್ಷಿತ ತಾತ್ಕಾಲಿಕ ಫೈಲ್ ಬಳಕೆ (B308): ಊಹಿಸಬಹುದಾದ ಸ್ಥಳದಲ್ಲಿ ತಾತ್ಕಾಲಿಕ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುವುದರಿಂದ ದಾಳಿಕೋರರು ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಅತಿಕ್ರಮಿಸಲು ಅಥವಾ ಓದಲು ಅನುಮತಿಸಬಹುದು.
- ಕಳೆದುಹೋದ ಅಥವಾ ತಪ್ಪಾದ ದೋಷ ನಿರ್ವಹಣೆ (B110): ವಿನಾಯಿತಿಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸದಿದ್ದರೆ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು ಅಥವಾ ಸೇವಾ ನಿರಾಕರಣೆ ದಾಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
ಉದಾಹರಣೆ: ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದುರ್ಬಲತೆಯನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ಸರಿಪಡಿಸುವುದು
ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದೌರ್ಬಲ್ಯವನ್ನು ಹೇಗೆ ಗುರುತಿಸುವುದು ಮತ್ತು ಸರಿಪಡಿಸುವುದು ಎಂಬುದರ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.
ಕೆಳಗಿನ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:
import subprocess
import os
def execute_command(command):
subprocess.Popen(command, shell=True)
if __name__ == "__main__":
user_input = input("Enter a command to execute: ")
execute_command(user_input)
ಈ ಕೋಡ್ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು subprocess.Popen ಅನ್ನು shell=True ನೊಂದಿಗೆ ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಶೆಲ್ ಆಜ್ಞೆಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇದು ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದುರ್ಬಲತೆಯ ಒಂದು ಕ್ಲಾಸಿಕ್ ಉದಾಹರಣೆಯಾಗಿದೆ.
ಈ ಕೋಡ್‌ನಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಚಲಾಯಿಸುವುದರಿಂದ ಕೆಳಗಿನ ಔಟ್‌ಪುಟ್ ಉತ್ಪತ್ತಿಯಾಗುತ್ತದೆ:
./example.py:4:0:B603 [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
Severity: High Confidence: High
Location: ./example.py:4
--------------------------------------------------
ಬ್ಯಾಂಡಿಟ್ subprocess.Popen ಅನ್ನು shell=True ನೊಂದಿಗೆ ಬಳಸುವುದು ಹೆಚ್ಚಿನ-ತೀವ್ರತೆಯ ದೌರ್ಬಲ್ಯ ಎಂದು ಸರಿಯಾಗಿ ಗುರುತಿಸುತ್ತದೆ.
ಈ ದೌರ್ಬಲ್ಯವನ್ನು ಸರಿಪಡಿಸಲು, ನೀವು shell=True ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಬೇಕು ಮತ್ತು ಬದಲಿಗೆ ಆಜ್ಞೆ ಮತ್ತು ಅದರ ವಾದಗಳನ್ನು ಪಟ್ಟಿಯಾಗಿ subprocess.Popen ಗೆ ರವಾನಿಸಬೇಕು. ದುರುದ್ದೇಶಪೂರಿತ ಆಜ್ಞೆಗಳನ್ನು ಚುಚ್ಚುವುದನ್ನು ತಡೆಯಲು ನೀವು ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಯಾನಿಟೈಸ್ ಮಾಡಬೇಕು.
ಕೋಡ್‌ನ ಸರಿಪಡಿಸಿದ ಆವೃತ್ತಿ ಇಲ್ಲಿದೆ:
import subprocess
import shlex
def execute_command(command):
# Sanitize the input using shlex.split to prevent shell injection
command_list = shlex.split(command)
subprocess.Popen(command_list)
if __name__ == "__main__":
user_input = input("Enter a command to execute: ")
execute_command(user_input)
ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಯಾನಿಟೈಸ್ ಮಾಡಲು shlex.split ಅನ್ನು ಬಳಸುವ ಮೂಲಕ ಮತ್ತು ಆಜ್ಞೆಯನ್ನು ಪಟ್ಟಿಯಾಗಿ subprocess.Popen ಗೆ ರವಾನಿಸುವ ಮೂಲಕ, ನೀವು ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದಾಳಿಯ ಅಪಾಯವನ್ನು ತಗ್ಗಿಸಬಹುದು.
ಸರಿಪಡಿಸಿದ ಕೋಡ್‌ನಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಚಲಾಯಿಸುವುದರಿಂದ ಇನ್ನು ಮುಂದೆ ಶೆಲ್ ಇಂಜೆಕ್ಷನ್ ದೌರ್ಬಲ್ಯವನ್ನು ವರದಿ ಮಾಡುವುದಿಲ್ಲ.
ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು
ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಅದರ ನಡವಳಿಕೆಯನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ (bandit.yaml ಅಥವಾ .bandit) ಬಳಸಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ನೀವು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಈ ಕೆಳಗಿನವುಗಳಿಗಾಗಿ ಬಳಸಬಹುದು:
- ಫೈಲ್‌ಗಳು ಅಥವಾ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಹೊರತುಪಡಿಸಿ: ಸ್ಕ್ಯಾನ್‌ನಿಂದ ಹೊರಗಿಡಬೇಕಾದ ಫೈಲ್‌ಗಳು ಅಥವಾ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.
- ನಿರ್ದಿಷ್ಟ ಪರೀಕ್ಷೆಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ: ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಸಂಬಂಧಿಸದ ಪರೀಕ್ಷೆಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ.
- ತೀವ್ರತೆ ಮಟ್ಟಗಳನ್ನು ಹೊಂದಿಸಿ: ನಿರ್ದಿಷ್ಟ ದೌರ್ಬಲ್ಯಗಳ ತೀವ್ರತೆ ಮಟ್ಟಗಳನ್ನು ಬದಲಾಯಿಸಿ.
- ಕಸ್ಟಮ್ ನಿಯಮಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ: ಪ್ರಾಜೆಕ್ಟ್-ನಿರ್ದಿಷ್ಟ ಭದ್ರತಾ ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನಿಮ್ಮ ಸ್ವಂತ ಕಸ್ಟಮ್ ನಿಯಮಗಳನ್ನು ರಚಿಸಿ.
bandit.yaml ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
exclude:
- 'tests/'
- 'docs/'
skips:
- 'B101'
confidence_level:
MEDIUM:
- 'B603'
severity_level:
LOW:
- 'B105'
ಈ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಸ್ಕ್ಯಾನ್‌ನಿಂದ tests/ ಮತ್ತು docs/ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಹೊರತುಪಡಿಸುತ್ತದೆ, B101 ಪರೀಕ್ಷೆಯನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ (ಇದು ಹೇಳಿಕೆಗಳ ಬಳಕೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ), B603 ಪರೀಕ್ಷೆಯ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮಟ್ಟವನ್ನು ಮಧ್ಯಮಕ್ಕೆ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು B105 ಪರೀಕ್ಷೆಯ ತೀವ್ರತೆ ಮಟ್ಟವನ್ನು ಕಡಿಮೆ ಎಂದು ಸರಿಹೊಂದಿಸುತ್ತದೆ.
ನಿಮ್ಮ CI/CD ಪೈಪ್‌ಲೈನ್‌ಗೆ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದು
ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್‌ನ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ CI/CD ಪೈಪ್‌ಲೈನ್‌ಗೆ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದು ಒಂದು ನಿರ್ಣಾಯಕ ಹಂತವಾಗಿದೆ. ಪ್ರತಿ ಕೋಡ್ ಬದಲಾವಣೆಯಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಚಲಾಯಿಸುವ ಮೂಲಕ, ನೀವು ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಆರಂಭದಲ್ಲಿಯೇ ಹಿಡಿಯಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಉತ್ಪಾದನೆಗೆ ತಲುಪದಂತೆ ತಡೆಯಬಹುದು.
ಗಿಟ್‌ಲ್ಯಾಬ್ CI/CD ಪೈಪ್‌ಲೈನ್‌ಗೆ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುವುದು ಎಂಬುದಕ್ಕೆ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
stages:
- test
bandit:
image: python:3.9
stage: test
before_script:
- pip install bandit
script:
- bandit -r .
artifacts:
reports:
bandit: bandit.report
ಈ ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಚಲಾಯಿಸುವ bandit ಕೆಲಸವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಕೆಲಸವು ಪೈಥಾನ್ 3.9 ಡಾಕರ್ ಚಿತ್ರವನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಪಿಪ್ ಬಳಸಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. bandit -r . ಆಜ್ಞೆಯು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಪೈಥಾನ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಚಲಾಯಿಸುತ್ತದೆ. artifacts ವಿಭಾಗವು ಬ್ಯಾಂಡಿಟ್ ವರದಿಯನ್ನು ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ ಆಗಿ ಉಳಿಸಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಇದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಪರಿಶೀಲಿಸಬಹುದು.
ಜೆನ್‌ಕಿನ್ಸ್, ಸರ್ಕಲ್‌ಸಿಐ ಮತ್ತು ಗಿಟ್‌ಹಬ್ ಆಕ್ಷನ್ಸ್‌ನಂತಹ ಇತರ CI/CD ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗಾಗಿ ಇದೇ ರೀತಿಯ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.
ಬ್ಯಾಂಡಿಟ್‌ನ ಹೊರತಾಗಿ: ಸಮಗ್ರ ಭದ್ರತಾ ತಂತ್ರಗಳು
ಸಂಭಾವ್ಯ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಲು ಬ್ಯಾಂಡಿಟ್ ಒಂದು ಅಮೂಲ್ಯ ಸಾಧನವಾಗಿದ್ದರೂ, ಇದು ಸಮಗ್ರ ಭದ್ರತಾ ತಂತ್ರದ ಒಂದು ಭಾಗ ಮಾತ್ರ ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಇತರ ಪ್ರಮುಖ ಭದ್ರತಾ ಅಭ್ಯಾಸಗಳು ಸೇರಿವೆ:
- ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳು: ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಪರಿಚಯಿಸುವ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಮಾರ್ಗಸೂಚಿಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ.
- ನಿಯಮಿತ ಭದ್ರತಾ ಆಡಿಟ್‌ಗಳು: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿನ ಸಂಭಾವ್ಯ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಪರಿಹರಿಸಲು ನಿಯಮಿತ ಭದ್ರತಾ ಆಡಿಟ್‌ಗಳನ್ನು ನಡೆಸಿ.
- ನುಗ್ಗುವ ಪರೀಕ್ಷೆ: ನೈಜ-ಪ್ರಪಂಚದ ದಾಳಿಗಳನ್ನು ಅನುಕರಿಸಲು ನುಗ್ಗುವ ಪರೀಕ್ಷೆಯನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಬ್ಯಾಂಡಿಟ್‌ನಂತಹ ಸ್ಥಿರ ವಿಶ್ಲೇಷಣಾ ಪರಿಕರಗಳಿಂದ ಪತ್ತೆಹಚ್ಚಲಾಗದ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಿ.
- ದೌರ್ಬಲ್ಯ ನಿರ್ವಹಣೆ: ನಿಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್ ಮತ್ತು ಮೂಲಸೌಕರ್ಯದಲ್ಲಿ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ದೌರ್ಬಲ್ಯ ನಿರ್ವಹಣೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅಳವಡಿಸಿ.
- ಅವಲಂಬನೆ ನಿರ್ವಹಣೆ: ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ತಿಳಿದಿರುವ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಪ್ಯಾಚ್ ಮಾಡಲು ನಿಮ್ಮ ಅವಲಂಬನೆಗಳನ್ನು ನವೀಕರಿಸಿ. `pip-audit` ಮತ್ತು `safety` ನಂತಹ ಪರಿಕರಗಳು ಇದಕ್ಕೆ ಸಹಾಯ ಮಾಡಬಹುದು.
- ಇನ್‌ಪುಟ್ ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ನೈರ್ಮಲ್ಯೀಕರಣ: ಇಂಜೆಕ್ಷನ್ ದಾಳಿಗಳು ಮತ್ತು ಇತರ ಇನ್‌ಪುಟ್-ಸಂಬಂಧಿತ ದೌರ್ಬಲ್ಯಗಳನ್ನು ತಡೆಯಲು ಯಾವಾಗಲೂ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ ಮತ್ತು ನೈರ್ಮಲ್ಯೀಕರಿಸಿ.
- ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ: ಸೂಕ್ಷ್ಮ ಡೇಟಾ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಕ್ಷಿಸಲು ಬಲವಾದ ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಅಳವಡಿಸಿ.
- ಭದ್ರತಾ ಅರಿವು ತರಬೇತಿ: ಸಾಮಾನ್ಯ ಭದ್ರತಾ ಬೆದರಿಕೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ಬಗ್ಗೆ ಅವರಿಗೆ ಶಿಕ್ಷಣ ನೀಡಲು ನಿಮ್ಮ ಡೆವಲಪರ್‌ಗಳು ಮತ್ತು ಇತರ ಉದ್ಯೋಗಿಗಳಿಗೆ ಭದ್ರತಾ ಅರಿವು ತರಬೇತಿಯನ್ನು ಒದಗಿಸಿ.
ತೀರ್ಮಾನ
ಪೈಥಾನ್ ಕೋಡ್‌ನಲ್ಲಿ ಭದ್ರತಾ ದೌರ್ಬಲ್ಯಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ತಗ್ಗಿಸಲು ಬ್ಯಾಂಡಿಟ್ ಒಂದು ಅಮೂಲ್ಯ ಸಾಧನವಾಗಿದೆ. ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವಿನಲ್ಲಿ ಬ್ಯಾಂಡಿಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಸುರಕ್ಷತೆಯನ್ನು ನೀವು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯ ಭದ್ರತಾ ಬೆದರಿಕೆಗಳಿಂದ ರಕ್ಷಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಬ್ಯಾಂಡಿಟ್ ಸಮಗ್ರ ಭದ್ರತಾ ತಂತ್ರದ ಒಂದು ಭಾಗ ಮಾತ್ರ ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯ. ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಯಮಿತ ಭದ್ರತಾ ಆಡಿಟ್‌ಗಳನ್ನು ನಡೆಸುವ ಮೂಲಕ ಮತ್ತು ಇತರ ಭದ್ರತಾ ಕ್ರಮಗಳನ್ನು ಅಳವಡಿಸುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಸಾಫ್ಟ್‌ವೇರ್ ಪರಿಸರವನ್ನು ರಚಿಸಬಹುದು.