Secure coding
ಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಎನ್ನುವುದು ಭದ್ರತಾ ದೋಷಗಳ ಆಕಸ್ಮಿಕ ಪರಿಚಯದ ವಿರುದ್ಧ ರಕ್ಷಿಸುವ ರೀತಿಯಲ್ಲಿ ಕಂಪ್ಯೂಟರ್ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಅಭ್ಯಾಸವಾಗಿದೆ. ದೋಷಗಳು, ದೋಷಗಳು ಮತ್ತು ತರ್ಕ ದೋಷಗಳು ನಿರಂತರವಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಿಕೊಳ್ಳುವ ಸಾಫ್ಟ್ವೇರ್ ದೋಷಗಳಿಗೆ ಪ್ರಾಥಮಿಕ ಕಾರಣಗಳಾಗಿವೆ. ವರದಿಯಾದ ಸಾವಿರಾರು ದೋಷಗಳ ವಿಶ್ಲೇಷಣೆಯ ಮೂಲಕ, ಭದ್ರತಾ ವೃತ್ತಿಪರರು ಹೆಚ್ಚಿನ ದೋಷಗಳು ತುಲನಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಸಾಮಾನ್ಯ ಸಾಫ್ಟ್ವೇರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ದೋಷಗಳಿಂದ ಉಂಟಾಗುತ್ತವೆ ಎಂದು ಕಂಡುಹಿಡಿದಿದ್ದಾರೆ. ಈ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುವ ಅಸುರಕ್ಷಿತ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳನ್ನು ಗುರುತಿಸುವ ಮೂಲಕ ಮತ್ತು ಸುರಕ್ಷಿತ ಪರ್ಯಾಯಗಳ ಬಗ್ಗೆ ಅಭಿವರ್ಧಕರಿಗೆ ಶಿಕ್ಷಣ ನೀಡುವ ಮೂಲಕ, ನಿಯೋಜನೆಯ ಮೊದಲು ಸಾಫ್ಟ್ವೇರ್ಗಳಲ್ಲಿನ ದೋಷಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಲು ಅಥವಾ ತೊಡೆದುಹಾಕಲು ಸಂಸ್ಥೆಗಳು ಪೂರ್ವಭಾವಿ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಸೈಬರ್ ಸುರಕ್ಷತೆಗೆ ಸಂಬಂಧಿಸಿದ ಬೆದರಿಕೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಎದುರಿಸಲು, ಸರಿಯಾದ ಭದ್ರತೆಯನ್ನು ಕೋಡ್ ಮಾಡಬೇಕು ಅಥವಾ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ "ಬೇಯಿಸಬೇಕು" ಎಂದು ಕೆಲವು ವಿದ್ವಾಂಸರು ಸೂಚಿಸಿದ್ದಾರೆ. ಸಾಫ್ಟ್ವೇರ್ನಲ್ಲಿ ಭದ್ರತೆಯನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದರಿಂದ, ಇದು ಆಂತರಿಕ ದಾಳಿಯ ವಿರುದ್ಧ ರಕ್ಷಣೆ ಇರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಭದ್ರತೆಗೆ ಬೆದರಿಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಬಫರ್-ಓವರ್ಫ್ಲೋ ತಡೆಗಟ್ಟುವಿಕೆ ಬಫರ್ ಓವರ್ಫ್ಲೋ, ಒಂದು ಸಾಮಾನ್ಯ ಸಾಫ್ಟ್ವೇರ್ ಭದ್ರತಾ ದುರ್ಬಲತೆ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ಸ್ಥಿರ-ಉದ್ದದ ಬಫರ್ ಅನ್ನು ಮೀರಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಸಂಭವಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ವಸ್ತುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು 8 ಸ್ಥಳಗಳಿದ್ದರೆ, 9 ವಸ್ತುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಸಮಸ್ಯೆ ಉಂಟಾಗುತ್ತದೆ. ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಯಲ್ಲಿ ಉಕ್ಕಿ ಹರಿಯುವ ದತ್ತಾಂಶವು ಮುಂದಿನ ಸ್ಥಳದಲ್ಲಿ ದತ್ತಾಂಶವನ್ನು ತಿದ್ದಿ ಬರೆಯಬಹುದು, ಇದು ಭದ್ರತಾ ದುರ್ಬಲತೆಗೆ (ಸ್ಟ್ಯಾಕ್ ಸ್ಮ್ಯಾಶಿಂಗ್) ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಮುಕ್ತಾಯಕ್ಕೆ (ವಿಭಜನೆಯ ದೋಷ) ಕಾರಣವಾಗಬಹುದು. ಬಫರ್ ಓವರ್ಫ್ಲೋಗೆ ಒಳಗಾಗುವ ಸಿ ಪ್ರೋಗ್ರಾಂನ ಉದಾಹರಣೆಯೆಂದರೆ isint ದುರ್ಬಲ _ ಕಾರ್ಯ (ಚಾರ * ದೊಡ್ಡ _ ಬಳಕೆದಾರ _ ಇನ್ಪುಟ್) {ಚಾರ ಡಿ. ಎಸ್. ಟಿ [ಎಸ್. ಎಂ. ಎ. ಎಲ್. ಎಲ್]; ಎಸ್. ಆರ್. ಸಿ. ಪಿ. ಐ (ಡಿ. ಎಸ್. ಟಿ, ದೊಡ್ಡ _ ಬಳಕೆದಾರ _ ಇನ್ಪುಟ್);} ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಗಮ್ಯಸ್ಥಾನದ ಬಫರ್ಗಿಂತ ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಬಫರ್ ಓವರ್ಫ್ಲೋ ಸಂಭವಿಸುತ್ತದೆ. ಈ ಅಸುರಕ್ಷಿತ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸರಿಪಡಿಸಲು, ಸಂಭವನೀಯ ಬಫರ್ overflow.int ಸೆಕ್ಯೂರ್ _ ಫಂಕ್ಷನ್ (ಚಾರ * ಯೂಸರ್ _ ಇನ್ಪುಟ್) ಅನ್ನು ತಡೆಯಲು ಸ್ಟ್ರಾಂಕ್ಪಿಯನ್ನು ಬಳಸಿ [ಚಾರ್ಡ್] [BUF _ SIZE];// ಗರಿಷ್ಠ BUF _ SIZE ಬೈಟ್ಗಳನ್ನು ಸ್ಟ್ರಾಂಕ್ಪಿಯನ್ನು ನಕಲಿಸಿ (dst, ಯೂಸರ್ _ ಇನ್ಪುಟ್, BUF _ SIZE);} ಮತ್ತೊಂದು ಸುರಕ್ಷಿತ ಪರ್ಯಾಯವೆಂದರೆ malloc.char * ಸೆಕ್ಯೂರ್ _ ಕಾಪಿ (ಚಾರ್ಡ್ * ಎಸ್ಆರ್ಸಿ) {ಸೈಜ್ _ ಟಿ ಲೆನ್ = ಸ್ಟ್ರ್ಲೆನ್ (ಎಸ್ಆರ್ಸಿ); ಚಾರ್ಡ್ * ಡಿಎಸ್ಟಿ = (ಚಾರ್ಡ್ *) ಮ್ಯಾಲೋಕ್ (ಲೆನ್ + 1); ಇಫ್ (ಡಿಎಸ್ಟಿ! = ಎನ್ಯುಎಲ್ಎಲ್) ಫಾರ್ಮ್ಯಾಟ್-ಸ್ಟ್ರಿಂಗ್ ಅಟ್ಯಾಕ್ ತಡೆಗಟ್ಟುವಿಕೆ ದುರುದ್ದೇಶಪೂರಿತ ಬಳಕೆದಾರರು ನಿರ್ದಿಷ್ಟ ಒಳಹರಿವುಗಳನ್ನು ಪೂರೈಸಿದಾಗ ಅದು ಅಂತಿಮವಾಗಿ ಪ್ರಿಂಟಫ್ () ನಂತಹ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮಾಡುವ ಕಾರ್ಯಕ್ಕೆ ವಾದವಾಗಿ ನಮೂದಿಸಲ್ಪಡುತ್ತದೆ. ದಾಳಿಯು ಎದುರಾಳಿಯು ಸ್ಟ್ಯಾಕ್ನಿಂದ ಓದುವುದನ್ನು ಅಥವಾ ಬರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸಿ ಪ್ರಿಂಟ್ಎಫ್ ಕಾರ್ಯವು ಸ್ಟ್ಡೌಟ್ಗೆ ಔಟ್ಪುಟ್ ಅನ್ನು ಬರೆಯುತ್ತದೆ. ಪ್ರಿಂಟ್ಎಫ್ ಕಾರ್ಯದ ನಿಯತಾಂಕವನ್ನು ಸರಿಯಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡದಿದ್ದರೆ, ಹಲವಾರು ಭದ್ರತಾ ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸಬಹುದು. attack.int ವಲ್ನರೇಬಲ್ _ ಪ್ರಿಂಟ್ (ಚಾರ * ಮಾಲಿಸಿಯಸ್ _ ಇನ್ಪುಟ್) {ಪ್ರಿಂಟಫ್ (ಮಾಲಿಸಿಯಸ್ _ ಇನ್ಪುಟ್);} ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ಗೆ ದುರ್ಬಲವಾಗಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ, ಪ್ರೋಗ್ರಾಂಗೆ ರವಾನಿಸಲಾದ ದುರುದ್ದೇಶಪೂರಿತ ವಾದವು "% s% s% s% s% s% s% s% s" ಆಗಿರಬಹುದು, ಇದು ಅಸಮರ್ಪಕ ಮೆಮೊರಿ ರೀಡ್ಗಳಿಂದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡಬಹುದು. ಪೂರ್ಣಾಂಕ-ಉಕ್ಕಿ ಹರಿಯುವಿಕೆ ತಡೆಗಟ್ಟುವಿಕೆ ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ ಹರಿಯುವಿಕೆಯು ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಯು ಲಭ್ಯವಿರುವ ಜಾಗದಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲು ತುಂಬಾ ದೊಡ್ಡದಾಗಿರುವ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಕಾರಣವಾದಾಗ ಸಂಭವಿಸುತ್ತದೆ. ಪೂರ್ಣಾಂಕದ ಓವರ್ಫ್ಲೋವನ್ನು ಸರಿಯಾಗಿ ಪರಿಶೀಲಿಸದ ಪ್ರೋಗ್ರಾಂ ಸಂಭಾವ್ಯ ಸಾಫ್ಟ್ವೇರ್ ದೋಷಗಳು ಮತ್ತು ಶೋಷಣೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಕೆಳಗೆ C + + ನಲ್ಲಿರುವ ಒಂದು ಕಾರ್ಯವು x ಮತ್ತು y ನ ಮೊತ್ತವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ದೃಢೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆಃ MAX: bool sumIsValid _ floed (ಸೈನ್ ಮಾಡದ int x, ಸೈನ್ ಮಾಡದ int y) {ಸೈನ್ ಮಾಡದ int sum = x + y; ಹಿಂತಿರುಗಿಸುವ ಮೊತ್ತ <= MAX;} ಕೋಡ್ನಲ್ಲಿನ ಸಮಸ್ಯೆಯೆಂದರೆ ಅದು ಅಡಿಷನ್ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಪೂರ್ಣಾಂಕದ ಓವರ್ಫ್ಲೋವನ್ನು ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ. x ಮತ್ತು y ನ ಮೊತ್ತವು ಸಹಿ ಮಾಡದ ಇಂಟಿನ ಗರಿಷ್ಠ ಸಂಭವನೀಯ ಮೌಲ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ, ಅಡಿಷನ್ ಕಾರ್ಯಾಚರಣೆಯು ಉಕ್ಕಿ ಹರಿಯುತ್ತದೆ ಮತ್ತು ಬಹುಶಃ x ಮತ್ತು y ನ ಮೊತ್ತವು MAX ಗಿಂತ ಹೆಚ್ಚಿದ್ದರೂ ಸಹ MAX ಗಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನವಾದ ಮೌಲ್ಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. x ಮತ್ತು y ಎರಡಕ್ಕೂ ಮೊತ್ತವು ದೊಡ್ಡದಾಗಿದೆ ಅಥವಾ ಸಮಾನವಾಗಿದೆ ಎಂದು ದೃಢೀಕರಿಸುವ ಮೂಲಕ ಉಕ್ಕಿ ಹರಿಯುವಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವ ಕಾರ್ಯವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಮೊತ್ತವು ಉಕ್ಕಿ ಹರಿದರೆ, ಮೊತ್ತವು x ಗಿಂತ ಕಡಿಮೆಯಿರುತ್ತದೆ ಅಥವಾ y ಗಿಂತ ಕಡಿಮೆಯಿರುತ್ತದೆ. bool sumIsValid _ ಸುರಕ್ಷಿತ (ಸಹಿ ಮಾಡದ int x, ಸಹಿ ಮಾಡದ int y) {ಸಹಿ ಮಾಡದ int sum = x + y; ಹಿಂತಿರುಗಿಸುವ ಮೊತ್ತ> = x & & sum> = y & & & sum <= MAX;} ಪಥ ಸಂಚಾರ ತಡೆಗಟ್ಟುವಿಕೆ ಮಾರ್ಗ ಸಂಚಾರವು ಒಂದು ದುರ್ಬಲತೆಯಾಗಿದ್ದು, ಇದರಿಂದಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ಮೂಲದಿಂದ ಒದಗಿಸಲಾದ ಮಾರ್ಗಗಳನ್ನು ಅನಧಿಕೃತ ಕಡತ ಪ್ರವೇಶವು ಸಾಧ್ಯವಾಗುವ ರೀತಿಯಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕಡತದ ಹೆಸರನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮೂಲಕ ಲೇಖನವನ್ನು ಪಡೆಯುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪರಿಗಣಿಸಿ, ನಂತರ ಅದನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ನಿಂದ ಓದಲಾಗುತ್ತದೆ ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡಲಾಗುತ್ತದೆ. ಅಂತಹ ಸ್ಕ್ರಿಪ್ಟ್ ನಾಯಿ ಆಹಾರದ ಬಗ್ಗೆ ಲೇಖನವನ್ನು ಹಿಂಪಡೆಯಲು ಈ ಕೆಳಗಿನ ಕಾಲ್ಪನಿಕ ಯುಆರ್ಎಲ್ ಅನ್ನು ಬಳಸಬಹುದುಃ https://www.example.net/cgi-bin/article.sh?name=dogfood.html ಸ್ಕ್ರಿಪ್ಟ್ ಯಾವುದೇ ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆಯನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಕಡತದ ಹೆಸರು ಯಾವಾಗಲೂ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ ಎಂದು ನಂಬುವ ಬದಲು, ದುರುದ್ದೇಶಪೂರಿತ ಬಳಕೆದಾರರು ವೆಬ್ ಸರ್ವರ್ನಿಂದ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ಗಳನ್ನು ಹಿಂಪಡೆಯಲು ಯುಆರ್ಎಲ್ ಅನ್ನು ನಕಲಿಸಬಹುದುಃ https://www.example.net/cgi-bin/article.sh?name=./././././etc/passwd ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಇದು/ಇತ್ಯಾದಿ/ಪಾಸ್ ಡಬ್ಲ್ಯೂಡಿ ಫೈಲ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು, ಇದು ಯುನಿಕ್ಸ್ ತರಹದ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ (ಇತರರ ನಡುವೆ) ಬಳಕೆದಾರರ ಐಡಿಗಳು, ಅವರ ಲಾಗಿನ್ ಹೆಸರುಗಳು, ಹೋಮ್ ಡೈರೆಕ್ಟರಿ ಮಾರ್ಗಗಳು ಮತ್ತು ಚಿಪ್ಪುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. (ಇದೇ ರೀತಿಯ ದಾಳಿಗಾಗಿ SQL ಚುಚ್ಚುಮದ್ದನ್ನು ನೋಡಿ.) ಅಪ್ಲಿಕೇಶನ್ ಸೆಕ್ಯುರಿಟಿ ಡಿಫೆನ್ಸಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸೆಕ್ಯುರಿಟಿ ಬಗ್ ಅನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನೋಡಿ ಟಿಪ್ಪಣಿಗಳು ಉಲ್ಲೇಖಗಳು ಕಂಪ್ಯೂಟರ್ ಸೆಕ್ಯುರಿಟಿ