Stack buffer overflow
ಸಾಫ್ಟ್ವೇರ್ನಲ್ಲಿ, ಉದ್ದೇಶಿತ ದತ್ತಾಂಶ ರಚನೆಯ ಹೊರಗೆ ಪ್ರೋಗ್ರಾಂನ ಕರೆ ಸ್ಟಾಕ್ನಲ್ಲಿರುವ ಮೆಮೊರಿ ವಿಳಾಸಕ್ಕೆ ಪ್ರೋಗ್ರಾಂ ಬರೆಯುವಾಗ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಅಥವಾ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ರನ್ ಸಂಭವಿಸುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಿರ-ಉದ್ದದ ಬಫರ್ ಆಗಿರುತ್ತದೆ. ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ದೋಷಗಳು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಸ್ಟ್ಯಾಕ್ನಲ್ಲಿರುವ ಬಫರ್ಗೆ ಆ ಬಫರ್ಗೆ ನಿಗದಿಪಡಿಸಿದ್ದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಡೇಟಾವನ್ನು ಬರೆಯುವಾಗ ಉಂಟಾಗುತ್ತವೆ. ಇದು ಬಹುತೇಕ ಯಾವಾಗಲೂ ಸ್ಟ್ಯಾಕ್ ಮೇಲಿನ ಪಕ್ಕದ ದತ್ತಾಂಶದ ಭ್ರಷ್ಟಾಚಾರಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ, ಮತ್ತು ತಪ್ಪಾಗಿ ಓವರ್ಫ್ಲೋ ಅನ್ನು ಪ್ರಚೋದಿಸಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಆಗಾಗ್ಗೆ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗಲು ಅಥವಾ ತಪ್ಪಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಎಂಬುದು ಬಫರ್ ಓವರ್ಫ್ಲೋ (ಅಥವಾ ಬಫರ್ ಓವರ್ ರನ್) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅಸಮರ್ಪಕ ಕ್ರಿಯೆಯ ಒಂದು ವಿಧವಾಗಿದೆ. ಸ್ಟ್ಯಾಕ್ ಮೇಲೆ ಬಫರ್ ಅನ್ನು ಅತಿಯಾಗಿ ತುಂಬಿಸುವುದರಿಂದ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಹೆಪ್ನಲ್ಲಿ ಬಫರ್ ಅನ್ನು ಅತಿಯಾಗಿ ತುಂಬುವುದಕ್ಕಿಂತ ಹಳಿ ತಪ್ಪುವ ಸಾಧ್ಯತೆಯಿದೆ ಏಕೆಂದರೆ ಸ್ಟ್ಯಾಕ್ ಎಲ್ಲಾ ಸಕ್ರಿಯ ಫಂಕ್ಷನ್ ಕರೆಗಳಿಗೆ ರಿಟರ್ನ್ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸ್ಟ್ಯಾಕ್ ಸ್ಮ್ಯಾಶಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುವ ದಾಳಿಯ ಭಾಗವಾಗಿ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಉಂಟಾಗಬಹುದು. ಬಾಧಿತ ಪ್ರೋಗ್ರಾಂ ವಿಶೇಷ ಸವಲತ್ತುಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ, ಅಥವಾ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ನೆಟ್ವರ್ಕ್ ಹೋಸ್ಟ್ಗಳಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಿದರೆ (ಉದಾ. ಒಂದು ವೆಬ್ ಸರ್ವರ್) ನಂತರ ದೋಷವು ಸಂಭಾವ್ಯ ಭದ್ರತಾ ದುರ್ಬಲತೆಯಾಗಿದೆ. ಸ್ಟಾಕ್ ಬಫರ್ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ಬಳಕೆದಾರರಿಂದ ಸರಬರಾಜು ಮಾಡಲಾದ ಡೇಟಾದಿಂದ ತುಂಬಿದ್ದರೆ, ಆ ಬಳಕೆದಾರರು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸುವ ರೀತಿಯಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಭ್ರಷ್ಟಗೊಳಿಸಬಹುದು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯ ನಿಯಂತ್ರಣವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ದಾಳಿಕೋರರು ಕಂಪ್ಯೂಟರ್ಗೆ ಅನಧಿಕೃತ ಪ್ರವೇಶವನ್ನು ಪಡೆಯಲು ಇದು ಅತ್ಯಂತ ಹಳೆಯ ಮತ್ತು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಸ್ಟ್ಯಾಕ್-ಆಧಾರಿತ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಅಂಗೀಕೃತ ವಿಧಾನವೆಂದರೆ ದಾಳಿಕೋರ-ನಿಯಂತ್ರಿತ ದತ್ತಾಂಶಕ್ಕೆ (ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ಯಾಕ್ನಲ್ಲಿಯೇ) ಪಾಯಿಂಟರ್ನೊಂದಿಗೆ ಫಂಕ್ಷನ್ ರಿಟರ್ನ್ ವಿಳಾಸವನ್ನು ತಿದ್ದಿ ಬರೆಯುವುದು. ಇದನ್ನು ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ಸ್ಟ್ರಾಕ್ಪಿ () ಯೊಂದಿಗೆ ವಿವರಿಸಲಾಗಿದೆಃ #include <string.h> ವಾಯ್ಡ್ ಫೂ (ಚಾರ್ * ಬಾರ್) {ಚಾರ್ ಸಿ [12]; ಸ್ಟ್ರಾಕ್ಪಿ (ಸಿ, ಬಾರ್);// ನೋ ಬೌಂಡ್ಸ್ ಚೆಕಿಂಗ್} ಇಂಟ್ ಮೈನ್ (ಇಂಟ್ ಆರ್ಗ್ಸಿ, ಚಾರ್ * * ಆರ್ಗ್ವಿ) {ಫೂ (ಆರ್ಗ್ವಿ [1]); ರಿಟರ್ನ್ 0;} ಈ ಕೋಡ್ ಕಮಾಂಡ್ ಲೈನ್ನಿಂದ ವಾದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸ್ಥಳೀಯ ಸ್ಟ್ಯಾಕ್ ವೇರಿಯೇಬಲ್ ಸಿಗೆ ನಕಲಿಸುತ್ತದೆ. ಇದು 12 ಅಕ್ಷರಗಳಿಗಿಂತ ಚಿಕ್ಕದಾದ ಕಮಾಂಡ್-ಲೈನ್ ವಾದಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ (ಕೆಳಗಿನ ಚಿತ್ರ ಬಿ ಯಲ್ಲಿ ನೋಡಬಹುದು). 11 ಅಕ್ಷರಗಳಿಗಿಂತ ದೊಡ್ಡದಾದ ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು ಸ್ಟಾಕ್ನ ಭ್ರಷ್ಟಾಚಾರಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ. (ಸುರಕ್ಷಿತವಾಗಿರುವ ಅಕ್ಷರಗಳ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯು ಇಲ್ಲಿ ಬಫರ್ನ ಗಾತ್ರಕ್ಕಿಂತ ಒಂದು ಕಡಿಮೆಯಾಗಿದೆ ಏಕೆಂದರೆ ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ, ತಂತಿಗಳನ್ನು ಶೂನ್ಯ ಬೈಟ್ ಅಕ್ಷರದಿಂದ ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹನ್ನೆರಡು-ಅಕ್ಷರಗಳ ಇನ್ಪುಟ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಹದಿಮೂರು ಬೈಟ್ಗಳು ಬೇಕಾಗುತ್ತವೆ, ಇನ್ಪುಟ್ ಅನ್ನು ಸೆಂಟಿನೆಲ್ ಶೂನ್ಯ ಬೈಟ್ ಅನುಸರಿಸುತ್ತದೆ. ಶೂನ್ಯ ಬೈಟ್ ನಂತರ ಬಫರ್ನ ಅಂತ್ಯವನ್ನು ಮೀರಿದ ಒಂದು ಬೈಟ್ನ ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಪುನಃ ಬರೆಯುತ್ತದೆ.) ಪ್ರೋಗ್ರಾಂ ವಿವಿಧ ಇನ್ಪುಟ್ಗಳೊಂದಿಗೆ ಫೂ () ನಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಮಾಡುತ್ತದೆಃ ಮೇಲಿನ ಚಿತ್ರ ಸಿ ಯಲ್ಲಿ, ಕಮಾಂಡ್ ಲೈನ್ನಲ್ಲಿ 11 ಬೈಟ್ಗಳಿಗಿಂತ ದೊಡ್ಡದಾದ ವಾದವನ್ನು ಒದಗಿಸಿದಾಗ ಫೂ () ಸ್ಥಳೀಯ ಸ್ಟ್ಯಾಕ್ ಡೇಟಾವನ್ನು, ಉಳಿಸಿದ ಫ್ರೇಮ್ ಪಾಯಿಂಟರ್ ಮತ್ತು ಮುಖ್ಯವಾಗಿ, ರಿಟರ್ನ್ ವಿಳಾಸವನ್ನು ತಿದ್ದಿ ಬರೆಯುತ್ತದೆ. ಫೂ () ಹಿಂತಿರುಗಿದಾಗ ಅದು ಸ್ಟ್ಯಾಕ್ನಿಂದ ಹಿಂದಿರುಗುವ ವಿಳಾಸವನ್ನು ಪಾಪ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಆ ವಿಳಾಸಕ್ಕೆ ಜಿಗಿಯುತ್ತದೆ (ಅಂದರೆ. ಆ ವಿಳಾಸದಿಂದ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ). ಹೀಗಾಗಿ, ದಾಳಿಕೋರನು ಹಿಂದಿರುಗುವ ವಿಳಾಸವನ್ನು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಚಾರ್ ಸಿ [12] ಗೆ ಪಾಯಿಂಟರಿನೊಂದಿಗೆ ತಿದ್ದಿ ಬರೆದಿದ್ದಾನೆ, ಇದು ಈಗ ದಾಳಿಕೋರರಿಂದ ಒದಗಿಸಲಾದ ದತ್ತಾಂಶವನ್ನು ಒಳಗೊಂಡಿದೆ. ನಿಜವಾದ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋದಲ್ಲಿ "ಎ" ಗಳ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಮತ್ತು ಅಪೇಕ್ಷಿತ ಕಾರ್ಯಕ್ಕೆ ಸೂಕ್ತವಾದ ಶೆಲ್ ಕೋಡ್ ಆಗಿರುತ್ತದೆ. ಈ ಕಾರ್ಯಕ್ರಮವು ವಿಶೇಷ ಸವಲತ್ತುಗಳನ್ನು ಹೊಂದಿದ್ದರೆ (ಉದಾ. ಎಸ್ಯುಐಡಿ ಬಿಟ್ ಅನ್ನು ಸೂಪರ್ ಯೂಸರ್ ಆಗಿ ಚಲಾಯಿಸಲು ಹೊಂದಿಸಲಾಗಿದೆ), ನಂತರ ಆಕ್ರಮಣಕಾರನು ಈ ದುರ್ಬಲತೆಯನ್ನು ಬಳಸಿ ಪೀಡಿತ ಯಂತ್ರದಲ್ಲಿ ಸೂಪರ್ ಯೂಸರ್ ಸವಲತ್ತುಗಳನ್ನು ಪಡೆಯಬಹುದು. ಆಕ್ರಮಣಕಾರನು ಕೆಲವು ದೋಷಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಆಂತರಿಕ ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯಗಳನ್ನು ಸಹ ಮಾರ್ಪಡಿಸಬಹುದು. ಈ ಉದಾಹರಣೆಯೊಂದಿಗೆಃ #include <string.h> #include <stdio.h> ವಾಯ್ಡ್ ಫೂ (ಚಾರ್ * ಬಾರ್) {ಫ್ಲೋಟ್ ಮೈ _ ಫ್ಲೋಟ್ = 10.5;// ಆಡ್ಆರ್ = 0x0023ಎಫ್ಎಫ್4ಸಿ ಚಾರ್ ಸಿ [28];// ಆಡ್ಆರ್ = 0x0023ಎಫ್ಎಫ್30// ಮುದ್ರಿಸುತ್ತದೆ 10.500000 ಪ್ರಿಂಟ್ಎಫ್ ("ಮೈ ಫ್ಲೋಟ್ ಮೌಲ್ಯ =% ಎಫ್", ಮೈ _ ಫ್ಲೋಟ್);/* ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ !!!! XXXX "); ಮೆಮ್ಕ್ಪೈ ಮೈ _ ಫ್ಲೋಟ್ ಮೌಲ್ಯದಲ್ಲಿ 0x1010C042 (ಲಿಟಲ್ ಎಂಡಿಯನ್) ಅನ್ನು ಇರಿಸುತ್ತದೆ. ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ !!!! \x10\x10\xc0\x42 "); ರಿಟರ್ನ್ 0;} ಪ್ಲಾಟ್ಫಾರ್ಮ್-ಸಂಬಂಧಿತ ವ್ಯತ್ಯಾಸಗಳು ಹಲವಾರು ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗಳು ಕಾಲ್ ಸ್ಟ್ಯಾಕ್ನ ಅನುಷ್ಠಾನದಲ್ಲಿ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿವೆ, ಅದು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಶೋಷಣೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಕೆಲವು ಯಂತ್ರ ವಿನ್ಯಾಸಗಳು ಕಾಲ್ ಸ್ಟ್ಯಾಕ್ನ ಉನ್ನತ ಮಟ್ಟದ ರಿಟರ್ನ್ ವಿಳಾಸವನ್ನು ರಿಜಿಸ್ಟರ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತವೆ. ಇದರರ್ಥ ಯಾವುದೇ ತಿದ್ದಿ ಬರೆದ ರಿಟರ್ನ್ ವಿಳಾಸವನ್ನು ನಂತರ ಕರೆ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಬಿಚ್ಚುವವರೆಗೆ ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಶೋಷಣೆ ತಂತ್ರಗಳ ಆಯ್ಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಯಂತ್ರ-ನಿರ್ದಿಷ್ಟ ವಿವರಗಳ ಮತ್ತೊಂದು ಉದಾಹರಣೆಯೆಂದರೆ, ಹೆಚ್ಚಿನ ಆರ್ಐಎಸ್ಸಿ-ಶೈಲಿಯ ಯಂತ್ರ ವಿನ್ಯಾಸಗಳು ಅಲಿಪ್ತ ಮೆಮೊರಿಗೆ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ. ಯಂತ್ರದ ಆಪ್ಕೋಡ್ಗಳ ನಿಗದಿತ ಉದ್ದದೊಂದಿಗೆ, ಈ ಯಂತ್ರ ಮಿತಿಯು ಸ್ಟ್ಯಾಕ್ಗೆ ಜಿಗಿಯುವ ತಂತ್ರವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಹುತೇಕ ಅಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ (ಒಂದು ವಿನಾಯಿತಿಯು ಪ್ರೋಗ್ರಾಂ ವಾಸ್ತವವಾಗಿ ಸ್ಟ್ಯಾಕ್ ರಿಜಿಸ್ಟರ್ಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಜಿಗಿಯಲು ಅಸಂಭವವಾದ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುವಾಗ). ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋಗಳ ವಿಷಯದಲ್ಲಿ, ಆಗಾಗ್ಗೆ ಚರ್ಚಿಸಲಾಗುವ-ಆದರೆ-ಅಪರೂಪವಾಗಿ-ಕಂಡುಬರುವ ವಾಸ್ತುಶಿಲ್ಪವು ಸ್ಟ್ಯಾಕ್ ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ ಬೆಳೆಯುತ್ತದೆ. ವಾಸ್ತುಶಿಲ್ಪದಲ್ಲಿನ ಈ ಬದಲಾವಣೆಯನ್ನು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವಾಗಿ ಆಗಾಗ್ಗೆ ಸೂಚಿಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅದೇ ಸ್ಟ್ಯಾಕ್ ಫ್ರೇಮ್ನೊಳಗೆ ಸಂಭವಿಸುವ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ನ ಯಾವುದೇ ಓವರ್ಫ್ಲೋ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಹಿಂದಿನ ಸ್ಟ್ಯಾಕ್ ಫ್ರೇಮ್ನಿಂದ ಬಫರ್ನಲ್ಲಿ ಸಂಭವಿಸುವ ಯಾವುದೇ ಓವರ್ಫ್ಲೋ ಇನ್ನೂ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯುತ್ತದೆ ಮತ್ತು ದೋಷವನ್ನು ದುರುದ್ದೇಶಪೂರಿತವಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಫೂಗಾಗಿ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯಲಾಗುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಓವರ್ಫ್ಲೋ ವಾಸ್ತವವಾಗಿ ಮೆಮ್ಸಿಪಿಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ನೊಳಗೆ ಸಂಭವಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಮೆಮ್ಸಿಪಿಯ ಕರೆಯ ಸಮಯದಲ್ಲಿ ಉಕ್ಕಿ ಹರಿಯುವ ಬಫರ್ ಹಿಂದಿನ ಸ್ಟ್ಯಾಕ್ ಫ್ರೇಮ್ನಲ್ಲಿರುವುದರಿಂದ, ಮೆಮ್ಸಿಪಿಯ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಬಫರ್ಗಿಂತ ಸಂಖ್ಯಾತ್ಮಕವಾಗಿ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇದರರ್ಥ ಫೂಗಾಗಿ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯುವ ಬದಲು, ಮೆಮ್ಸಿಪಿಯ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯಲಾಗುತ್ತದೆ. ಗರಿಷ್ಠವಾಗಿ, ಇದರರ್ಥ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ ಬೆಳೆಸುವುದು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋಗಳನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳಬಹುದು ಎಂಬುದರ ಕೆಲವು ವಿವರಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಶೋಷಿಸಬಹುದಾದ ದೋಷಗಳ ಸಂಖ್ಯೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುವುದಿಲ್ಲ. ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ, ದುರುದ್ದೇಶಪೂರಿತ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಶೋಷಣೆಯನ್ನು ತಡೆಯಲು ಹಲವಾರು ನಿಯಂತ್ರಣ-ಹರಿವಿನ ಸಮಗ್ರತೆಯ ಯೋಜನೆಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. ಇವುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಮೂರು ವರ್ಗಗಳಾಗಿ ವರ್ಗೀಕರಿಸಬಹುದುಃ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಸಂಭವಿಸಿದೆ ಎಂದು ಪತ್ತೆಹಚ್ಚಿರಿ ಮತ್ತು ಹೀಗೆ ಸೂಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ಗೆ ಮರುನಿರ್ದೇಶಿಸುವುದನ್ನು ತಡೆಯಿರಿ. ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ನೇರವಾಗಿ ಪತ್ತೆ ಮಾಡದೆಯೇ ಸ್ಟ್ಯಾಕ್ನಿಂದ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ತಡೆಯಿರಿ. ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದಂತೆ ಮೆಮೊರಿ ಜಾಗವನ್ನು ಯಾದೃಚ್ಛಿಕಗೊಳಿಸಿ. ಕಲ್ಲಿದ್ದಲು ಗಣಿಯಲ್ಲಿನ ಕ್ಯಾನರಿಗೆ ಹೋಲಿಕೆಯಾಗಿರುವುದಕ್ಕಾಗಿ ಹೆಸರಿಸಲಾದ ಸ್ಟ್ಯಾಕ್ ಕ್ಯಾನರಿಗಳನ್ನು, ದುರುದ್ದೇಶಪೂರಿತ ಸಂಕೇತವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಣ್ಣ ಪೂರ್ಣಾಂಕವನ್ನು ಇರಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅದರ ಮೌಲ್ಯವನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭದಲ್ಲಿ, ಸ್ಟಾಕ್ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ಗೆ ಸ್ವಲ್ಪ ಮೊದಲು ಮೆಮೊರಿಯಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ಬಫರ್ ಓವರ್ಫ್ಲೋಗಳು ಮೆಮೊರಿಯನ್ನು ಕೆಳಗಿನಿಂದ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ವಿಳಾಸಗಳಿಗೆ ತಿದ್ದಿ ಬರೆಯುತ್ತವೆ, ಆದ್ದರಿಂದ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ತಿದ್ದಿ ಬರೆಯಲು (ಮತ್ತು ಹೀಗೆ ಪ್ರಕ್ರಿಯೆಯ ನಿಯಂತ್ರಣವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು) ಕ್ಯಾನರಿ ಮೌಲ್ಯವನ್ನು ಸಹ ತಿದ್ದಿ ಬರೆಯಬೇಕು. ಸ್ಟ್ಯಾಕ್ ಮೇಲೆ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ವಾಡಿಕೆಯು ಬಳಸುವ ಮೊದಲು ಅದು ಬದಲಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಈ ತಂತ್ರವು ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಕಷ್ಟವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಸ್ಟ್ಯಾಕ್ ಮೇಲಿನ ಇತರ ಪ್ರಮುಖ ಅಸ್ಥಿರಗಳನ್ನು ಭ್ರಷ್ಟಗೊಳಿಸುವಂತಹ ಕೆಲವು ಸಾಂಪ್ರದಾಯಿಕವಲ್ಲದ ವಿಧಾನಗಳಿಂದ ಸೂಚನಾ ಪಾಯಿಂಟರ್ ಅನ್ನು ನಿಯಂತ್ರಿಸಲು ಆಕ್ರಮಣಕಾರರನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ. ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಶೋಷಣೆಯನ್ನು ತಡೆಗಟ್ಟುವ ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಸ್ಟ್ಯಾಕ್ ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿ ಮೆಮೊರಿ ನೀತಿಯನ್ನು ಜಾರಿಗೊಳಿಸುವುದು, ಅದು ಸ್ಟ್ಯಾಕ್ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ (W ^ X, "ರೈಟ್ XOR ಎಕ್ಸಿಕ್ಯೂಟ್"). ಇದರರ್ಥ ಸ್ಟ್ಯಾಕ್ನಿಂದ ಶೆಲ್ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆಕ್ರಮಣಕಾರರು ಮೆಮೊರಿಯಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸುವ ರಕ್ಷಣೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಳ್ಳಬೇಕು ಅಥವಾ ತಮ್ಮ ಶೆಲ್ಕೋಡ್ ಪೇಲೋಡ್ ಅನ್ನು ಮೆಮೊರಿಯ ಸಂರಕ್ಷಿತವಲ್ಲದ ಪ್ರದೇಶದಲ್ಲಿ ಇರಿಸುವ ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಳ್ಳಬೇಕು. ಹೆಚ್ಚಿನ ಡೆಸ್ಕ್ಟಾಪ್ ಪ್ರೊಸೆಸರ್ಗಳಲ್ಲಿ ನೋ-ಎಕ್ಸಿಕ್ಯೂಟ್ ಫ್ಲ್ಯಾಗ್ಗೆ ಹಾರ್ಡ್ವೇರ್ ಬೆಂಬಲವು ಲಭ್ಯವಿರುವುದರಿಂದ ಈ ವಿಧಾನವು ಈಗ ಹೆಚ್ಚು ಜನಪ್ರಿಯವಾಗುತ್ತಿದೆ. ಈ ವಿಧಾನವು ಕ್ಯಾನೊನಿಕಲ್ ಸ್ಟ್ಯಾಕ್ ಸ್ಮ್ಯಾಶಿಂಗ್ ಶೋಷಣೆಯನ್ನು ತಡೆಯುತ್ತದೆಯಾದರೂ, ಸ್ಟ್ಯಾಕ್ ಓವರ್ಫ್ಲೋಗಳನ್ನು ಇತರ ರೀತಿಯಲ್ಲಿ ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಮೊದಲನೆಯದಾಗಿ, ಶೇಖರಣೆಯಂತಹ ಅಸುರಕ್ಷಿತ ಮೆಮೊರಿ ಪ್ರದೇಶಗಳಲ್ಲಿ ಶೆಲ್ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುವ ಮಾರ್ಗಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದ್ದರಿಂದ ಶೋಷಣೆಯ ರೀತಿಯಲ್ಲಿ ಬಹಳ ಕಡಿಮೆ ಬದಲಾವಣೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ. ಮತ್ತೊಂದು ದಾಳಿಯು ಶೆಲ್ಕೋಡ್ ಸೃಷ್ಟಿಗಾಗಿ ಲಿಬ್ಸಿ ವಿಧಾನಕ್ಕೆ ಮರಳುವುದು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ. ಈ ದಾಳಿಯಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಪೇಲೋಡ್ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಶೆಲ್ಕೋಡ್ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಸರಿಯಾದ ಕರೆ ಸ್ಟ್ಯಾಕ್ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿ ಕರೆಗಳ ಸರಪಳಿಗೆ ವಾಹಕವಾಗಿದೆ, ಸಾಮಾನ್ಯವಾಗಿ ಮೆಮೊರಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ರಕ್ಷಣೆಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಪರಿಣಾಮ ಮತ್ತು ಶೆಲ್ಕೋಡ್ ಅನ್ನು ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ಚಲಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ವಾಸ್ತವವಾಗಿ ಸ್ಟಾಕ್ಗೆ ವಾಹಕಗಳನ್ನು ಎಂದಿಗೂ ಹೊಂದಿರುವುದಿಲ್ಲ. ರಿಟರ್ನ್-ಟು-ಲಿಬ್ಸಿಯ ಒಂದು ರೂಪಾಂತರವೆಂದರೆ ರಿಟರ್ನ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (ಆರ್ಓಪಿ), ಇದು ರಿಟರ್ನ್ ವಿಳಾಸಗಳ ಸರಣಿಯನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಅಥವಾ ಸಿಸ್ಟಮ್ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಚೆರ್ರಿ-ಆಯ್ದ ಯಂತ್ರ ಸೂಚನೆಗಳ ಸಣ್ಣ ಅನುಕ್ರಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಇದು ರಿಟರ್ನ್ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಈ ಗ್ಯಾಜೆಟ್ಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ಪ್ರತಿಯೊಂದೂ ಹಿಂದಿರುಗುವ ಮೊದಲು ಕೆಲವು ಸರಳವಾದ ರಿಜಿಸ್ಟರ್ ಕುಶಲತೆಯನ್ನು ಅಥವಾ ಅಂತಹುದೇ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಾಧಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸುವುದರಿಂದ ಆಕ್ರಮಣಕಾರರ ಗುರಿಗಳನ್ನು ಸಾಧಿಸುತ್ತದೆ. ಹಿಂತಿರುಗಿಸುವ ಸೂಚನೆಯಂತೆ ವರ್ತಿಸುವ ಸೂಚನೆಗಳು ಅಥವಾ ಸೂಚನೆಗಳ ಗುಂಪುಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ "ಹಿಂತಿರುಗಿಸದ" ರಿಟರ್ನ್-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸಹ ಬಳಸಲು ಸಾಧ್ಯವಿದೆ. ಕೋಡ್ ಅನ್ನು ದತ್ತಾಂಶದಿಂದ ಬೇರ್ಪಡಿಸುವ ಬದಲು, ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರೋಗ್ರಾಂನ ಮೆಮೊರಿ ಜಾಗಕ್ಕೆ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಪರಿಚಯಿಸುವುದು ಮತ್ತೊಂದು ತಗ್ಗಿಸುವಿಕೆಯ ತಂತ್ರವಾಗಿದೆ. ಬಳಸಬಹುದಾದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಎಲ್ಲಿದೆ ಎಂಬುದನ್ನು ಆಕ್ರಮಣಕಾರನು ನಿರ್ಧರಿಸಬೇಕಾಗಿರುವುದರಿಂದ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಪೇಲೋಡ್ ಅನ್ನು ಒದಗಿಸಲಾಗುತ್ತದೆ (ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸ್ಟಾಕ್ನೊಂದಿಗೆ) ಅಥವಾ ರೆಟ್2ಲಿಬಿಸಿ ಅಥವಾ ರಿಟರ್ನ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (ಆರ್ಒಪಿ) ನಂತಹ ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದನ್ನು ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ. ಮೆಮೊರಿ ವಿನ್ಯಾಸವನ್ನು ಯಾದೃಚ್ಛಿಕಗೊಳಿಸುವುದರಿಂದ, ಒಂದು ಪರಿಕಲ್ಪನೆಯಾಗಿ, ಯಾವುದೇ ಕೋಡ್ ಎಲ್ಲಿದೆ ಎಂದು ಆಕ್ರಮಣಕಾರರಿಗೆ ತಿಳಿಯುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಅನುಷ್ಠಾನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಎಲ್ಲವನ್ನೂ ಯಾದೃಚ್ಛಿಕಗೊಳಿಸುವುದಿಲ್ಲ; ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸಾಧನವನ್ನು ನಿಗದಿತ ವಿಳಾಸದಲ್ಲಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಎಎಸ್ಎಲ್ಆರ್ (ಅಡ್ರೆಸ್ ಸ್ಪೇಸ್ ಲೇಔಟ್ ಯಾದೃಚ್ಛಿಕತೆ) ಅನ್ನು ಅಸಮರ್ಥನೀಯ ಸ್ಟ್ಯಾಕ್ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದರೂ ಸಹ ಆಕ್ರಮಣಕಾರರು ಈ ಸ್ಥಿರ ಮೆಮೊರಿ ಪ್ರದೇಶವನ್ನು ಬಳಸಬಹುದು. ಆದ್ದರಿಂದ, ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಪಿಐಇ (ಸ್ಥಾನ-ಸ್ವತಂತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗಳು) ಯೊಂದಿಗೆ ಸಂಕಲಿಸಬೇಕು, ಅಂದರೆ ಈ ಮೆಮೊರಿ ಪ್ರದೇಶವೂ ಸಹ ಯಾದೃಚ್ಛಿಕವಾಗಿರುತ್ತದೆ. ಯಾದೃಚ್ಛಿಕತೆಯ ಎಂಟ್ರೊಪಿಯು ಅನುಷ್ಠಾನದಿಂದ ಅನುಷ್ಠಾನಕ್ಕೆ ಭಿನ್ನವಾಗಿದೆ ಮತ್ತು ಯಾದೃಚ್ಛಿಕವಾಗಿರುವ ಮೆಮೊರಿ ಜಾಗವನ್ನು ಬ್ರೂಟ್ ಒತ್ತಾಯಿಸುವ ವಿಷಯದಲ್ಲಿ ಸಾಕಷ್ಟು ಕಡಿಮೆ ಎಂಟ್ರೊಪಿಯು ಸ್ವತಃ ಒಂದು ಸಮಸ್ಯೆಯಾಗಿರಬಹುದು. ಬೈಪಾಸ್ ಪ್ರತಿಕ್ರಮಗಳು ಹಿಂದಿನ ಉಪಶಮನಗಳು ಶೋಷಣೆಯ ಹಂತಗಳನ್ನು ಕಠಿಣಗೊಳಿಸುತ್ತವೆ. ಆದರೆ ಕೆಲವು ದೋಷಗಳು ಪ್ರಸ್ತುತವಾಗಿದ್ದರೆ ಅಥವಾ ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಿದರೆ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಇನ್ನೂ ಸಾಧ್ಯವಿದೆ. ಸ್ಟ್ಯಾಕ್ ಕ್ಯಾನರಿ ಬೈಪಾಸ್ ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ ದುರ್ಬಲತೆಯ ಶೋಷಣೆಯೊಂದಿಗೆ ಮಾಹಿತಿ ಸೋರಿಕೆ ಆಕ್ರಮಣಕಾರನು ದುರ್ಬಲ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿನ ಮೆಮೊರಿ ಸ್ಥಳಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಲು ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ ದುರ್ಬಲತೆಯನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಡೇಟಾ ಎಕ್ಸಿಕ್ಯುಷನ್ ಪ್ರಿವೆನ್ಷನ್ ಅನ್ನು ಸ್ಟ್ಯಾಕ್ಗೆ ಯಾವುದೇ ಎಕ್ಸಿಕ್ಯುಟ್ ಪ್ರವೇಶವನ್ನು ನಿಷೇಧಿಸಲು ಸಕ್ರಿಯಗೊಳಿಸಿದಾಗ, ಅಟ್ಯಾಕರ್ ಇನ್ನೂ ಕೋಡ್ ವಿಭಾಗದಲ್ಲಿ (ಲಿನಕ್ಸ್ನಲ್ಲಿ) ಅಥವಾ ಪ್ರೋಗ್ರಾಂನ ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ವಿಭಾಗದಲ್ಲಿನ ಡೇಟಾವನ್ನು ಸೂಚಿಸಲು ತಿದ್ದಿ ಬರೆದ ರಿಟರ್ನ್ ವಿಳಾಸವನ್ನು (ಇನ್ಸ್ಟ್ರಕ್ಷನ್ ಪಾಯಿಂಟರ್) ಬಳಸಬಹುದು. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವುದು ಇದರ ಗುರಿಯಾಗಿದೆ. ರೋಪ್ ಸರಪಳಿಯು ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಂನ ರಿಟರ್ನ್ ಇನ್ಸ್ಟ್ರಕ್ಷನ್ಗೆ ಸ್ವಲ್ಪ ಮೊದಲು (x86 ರಲ್ಲಿ ರಿಟ್ರೀಟ್) ತಿದ್ದಿ ಬರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಹೊಸ ರಿಟರ್ನ್ ಪಾಯಿಂಟರ್ ಮತ್ತು ರಿಟರ್ನ್ ಸೂಚನೆಗಳ ನಡುವಿನ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ರಿಟರ್ನ್ ಸೂಚನೆಯು ಶೋಷಕನು ನಿಯಂತ್ರಿಸುವ ಪೇಲೋಡ್ಗೆ ಮರಳುತ್ತದೆ. ಜೋಪ್ ಚೈನ್ ಜಂಪ್ ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂಬುದು ಒಂದು ತಂತ್ರವಾಗಿದ್ದು, ಇದು ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವ ಬದಲು ಮರುಬಳಕೆ ಮಾಡಲು ಜಂಪ್ ಸೂಚನೆಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಯಾದೃಚ್ಛಿಕ ಬೈಪಾಸ್ 64-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಎಎಸ್ಎಲ್ಆರ್ ಸಾಕ್ಷಾತ್ಕಾರದ ಒಂದು ಮಿತಿಯೆಂದರೆ ಅದು ಮೆಮೊರಿ ಬಹಿರಂಗಪಡಿಸುವಿಕೆ ಮತ್ತು ಮಾಹಿತಿ ಸೋರಿಕೆ ದಾಳಿಗಳಿಗೆ ಗುರಿಯಾಗುತ್ತದೆ. ಮಾಹಿತಿ ಸೋರಿಕೆ ದಾಳಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಏಕೈಕ ಕಾರ್ಯ ವಿಳಾಸವನ್ನು ಬಹಿರಂಗಪಡಿಸುವ ಮೂಲಕ ದಾಳಿಕೋರನು ಆರ್. ಓ. ಪಿ. ಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಈ ಕೆಳಗಿನ ವಿಭಾಗವು ಎಎಸ್ಎಲ್ಆರ್ ರಕ್ಷಣೆಯನ್ನು ಮುರಿಯಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಇದೇ ರೀತಿಯ ಕಾರ್ಯತಂತ್ರವನ್ನು ವಿವರಿಸುತ್ತದೆ. ಗಮನಾರ್ಹ ಉದಾಹರಣೆಗಳೆಂದರೆ, 1988ರಲ್ಲಿ ಮೋರಿಸ್ ವರ್ಮ್ ಯುನಿಕ್ಸ್ ಫಿಂಗರ್ ಸರ್ವರ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಭಾಗಶಃ ಹರಡಿತು. 2003ರಲ್ಲಿ ಸ್ಲ್ಯಾಮರ್ ವರ್ಮ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ನ SQL ಸರ್ವರ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಹರಡಿತು. 2003ರಲ್ಲಿ ಬ್ಲಾಸ್ಟರ್ ವರ್ಮ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಡಿಸಿಒಎಂ ಸೇವೆಯಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಹರಡಿತು. 2004ರಲ್ಲಿ ಇಂಟರ್ನೆಟ್ ಸೆಕ್ಯುರಿಟಿ ಸಿಸ್ಟಮ್ಸ್ ಬ್ಲ್ಯಾಕ್ಐಸಿಇ ಡೆಸ್ಕ್ಟಾಪ್ ಏಜೆಂಟ್ನಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಬಫರ್ ಓವರ್ಫ್ಲೋವನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ ವಿಟ್ಟಿ ವರ್ಮ್ ಹರಡಿತು. ಮಾರ್ಪಡಿಸದ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅನಿಯಂತ್ರಿತ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅನುಮತಿಸುವ ವೈಗೆ ಒಂದೆರಡು ಉದಾಹರಣೆಗಳಿವೆ. ದಿ ಲೆಜೆಂಡ್ ಆಫ್ ಜೆಲ್ಡಾಃ ಟ್ವಿಲೈಟ್ ಪ್ರಿನ್ಸೆಸ್ನಲ್ಲಿ ಮುಖ್ಯ ಪಾತ್ರದ ಕುದುರೆಗೆ ಸುದೀರ್ಘವಾದ ಹೆಸರನ್ನು ನೀಡುವ "ಟ್ವಿಲೈಟ್ ಹ್ಯಾಕ್" ಮತ್ತು ಸೂಪರ್ ಸ್ಮ್ಯಾಶ್ ಬ್ರದರ್ಸ್ ಬ್ರಾಲ್ಗಾಗಿ "ಸ್ಮ್ಯಾಶ್ ಸ್ಟಾಕ್" ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ಆಟದಲ್ಲಿನ ಮಟ್ಟದ ಸಂಪಾದಕಕ್ಕೆ ವಿಶೇಷವಾಗಿ ಸಿದ್ಧಪಡಿಸಿದ ಫೈಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಎಸ್ಡಿ ಕಾರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಯಾವುದೇ ಅನಿಯಂತ್ರಿತ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಎರಡನ್ನೂ ಬಳಸಬಹುದಾದರೂ, ಎರಡನೆಯದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಅನ್ವಯಿಸಲಾದ ಮಾರ್ಪಾಡುಗಳೊಂದಿಗೆ ಬ್ರಾಲ್ ಅನ್ನು ಮರುಲೋಡ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಎಕ್ಸೆಕ್ಶೀಲ್ಡ್ ಹೀಪ್ ಓವರ್ಫ್ಲೋ ಪೂರ್ಣಾಂಕ ಓವರ್ಫ್ಲೋ ಎನ್ಎಕ್ಸ್ ಬಿಟ್ ಅನ್ನು ಸಹ ನೋಡಿ-ಮೆಮೊರಿ ಸೆಕ್ಯುರಿಟಿ-ವರ್ಧಿತ ಲಿನಕ್ಸ್ ಸ್ಟಾಕ್ ಓವರ್ಫ್ಲೋ ಪ್ರದೇಶಗಳಿಗೆ ನೋ-ಎಕ್ಸಿಕ್ಯೂಟ್ ಬಿಟ್-ಸ್ಟಾಕ್ ಸ್ವತಃ ಶೇಖರಣಾ ಉಲ್ಲಂಘನೆಯನ್ನು ಓವರ್ಫ್ಲೋ ಮಾಡಿದಾಗ ಉಲ್ಲೇಖಗಳು ಸಾಫ್ಟ್ವೇರ್ ದೋಷಗಳು ಸಾಫ್ಟ್ವೇರ್ ವೈಪರೀತ್ಯಗಳು ಕಂಪ್ಯೂಟರ್ ಭದ್ರತೆಯು ಕಂಪ್ಯೂಟರ್ ದೋಷಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ