ದುರ್ಬಲತೆಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ನೋಟ

ಈ ವಿಷಯದ ಬಗ್ಗೆ ಚರ್ಚಿಸುವುದನ್ನು ಮುಂದುವರೆಸಲು ನಾನು ಎದುರು ನೋಡುತ್ತಿದ್ದಾಗ, ದುರ್ಬಲತೆಗಳ ಕುರಿತು ಸ್ವಲ್ಪ ಇತಿಹಾಸ, ಸಿದ್ಧಾಂತ ಮತ್ತು ಅಭ್ಯಾಸವನ್ನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ಭದ್ರತಾ ನ್ಯೂನತೆಗಳಿಗೆ ಸಾಕಷ್ಟು ವೆಚ್ಚವಾಗಬಹುದು ಎಂದು ನಾವೆಲ್ಲರೂ ಈಗ ಕೇಳಿದ್ದೇವೆ, ನಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಾವು ನವೀಕೃತವಾಗಿರಿಸಿಕೊಳ್ಳಬೇಕು ಎಂದು ನಮಗೆಲ್ಲರಿಗೂ ತಿಳಿದಿದೆ, ಭದ್ರತಾ ದೋಷಗಳಿಂದಾಗಿ ಅನೇಕ ನವೀಕರಣಗಳು ಉಂಟಾಗುತ್ತವೆ ಎಂದು ನಮಗೆಲ್ಲರಿಗೂ ತಿಳಿದಿದೆ. ಆದರೆ ಈ ದೋಷಗಳು ಹೇಗೆ ಕಂಡುಬರುತ್ತವೆ ಮತ್ತು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು ಇಂದು ನಾನು ನಿಮಗೆ ಸ್ವಲ್ಪ ಹೇಳುತ್ತೇನೆ 🙂 ಆದರೆ ಇದಕ್ಕೂ ಮುನ್ನ ನಾವು ಉತ್ತಮ ಅವಲೋಕನವನ್ನು ಹೊಂದಲು ಕೆಲವು ವಿವರಗಳನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲಿದ್ದೇವೆ.

ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು

ಮೊದಲಿಗೆ ನಾನು ನಿಮಗೆ ಹೇಳಲು ಬಯಸುತ್ತೇನೆ ನಾನು ತಿಳಿದಿರುವ ಮೊದಲ ದುರ್ಬಳಕೆಯ ಮೇಲೆ ನಾವು ಗಮನ ಹರಿಸಲಿದ್ದೇವೆ ಬಫರ್ ಉಕ್ಕಿ ಹರಿಯುತ್ತದೆ, ಈ ದುರ್ಬಲತೆಯಲ್ಲಿ ನಾವು ಮೋಜಿನ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಮೆಮೊರಿ ಪರಿಶೀಲನೆಯ ಕೊರತೆಯ ಲಾಭವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ 🙂 ಆದರೆ ಇದರ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ಪಷ್ಟಪಡಿಸೋಣ.

ಇದು ನೈಜ ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶವಾಗುವುದಿಲ್ಲ

ಅವರು ನೋಡುವ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮುರಿಯಲು ಅವರಿಗೆ ಕಲಿಸಲು ನನಗೆ ಸಾಧ್ಯವಿಲ್ಲ - ಮೊದಲು ಅದು ಅವರ ಕಂಪ್ಯೂಟರ್‌ಗಳಿಗೆ ಅಪಾಯಕಾರಿ, ಎರಡನೆಯದು ಏಕೆಂದರೆ ಅದು ನನ್ನ ಸಾಮಾನ್ಯ ಪದಗಳಿಗಿಂತ ಹೆಚ್ಚಿನದನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ನಾವು 80 ರ ದಶಕಕ್ಕೆ ಪ್ರವಾಸಕ್ಕೆ ಹೋಗುತ್ತೇವೆ

ನನ್ನ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಲ್ಲಿ ನಾನು ಏನು ಮಾಡಬಹುದೆಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸಲಿದ್ದೇನೆ, ಆದರೆ ಇದನ್ನು ಇಂದು ಸರಳ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದೆಂದು ಇದರ ಅರ್ಥವಲ್ಲ these ಈ ಅನೇಕ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಈಗಾಗಲೇ ಹಲವು ಬಾರಿ ಬಳಸಿಕೊಳ್ಳಲಾಗಿದೆ ಹೊಸ ರಕ್ಷಣಾ ವಿಧಾನಗಳು ಮತ್ತು ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಹೊಸ ವಿಧಾನಗಳು ಅವು ಹೊರಹೊಮ್ಮಿವೆ 😛 ಆದರೆ ಅದು ನಮ್ಮನ್ನು ಅದೇ ಸ್ಥಳಕ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅದನ್ನೆಲ್ಲ ಹೇಳಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ

ಇದು ನಿಮ್ಮ ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸದೆ ಇರಬಹುದು

ನಾನು ತುಂಬಾ ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಲಿದ್ದರೂ, ಇದರ ವಿವರಗಳು ಹಲವು ಮತ್ತು ವೈವಿಧ್ಯಮಯವಾಗಿವೆ ಎಂಬುದು ಮೊದಲಿನಿಂದಲೂ ಸ್ಪಷ್ಟವಾಗಿರಬೇಕು ಎಂದು ನಾನು ಬಯಸುತ್ತೇನೆ, ನೀವು ಅದನ್ನು ಪ್ರಯತ್ನಿಸಲು ಬಯಸಿದರೆ ಅದು ನನ್ನಂತೆಯೇ ಹೊರಬರಬಹುದು. , ಅಪೇಕ್ಷಿತ ಪರಿಣಾಮವನ್ನು ಸಹ ಸಾಧಿಸಲಾಗುವುದಿಲ್ಲ 🙂 ಆದರೆ ಈ ಜಾಗದಲ್ಲಿ ನಾನು ಅದನ್ನು ವಿವರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನೀವು can ಹಿಸಬಹುದು, ಅದರಲ್ಲೂ ವಿಶೇಷವಾಗಿ ಈ ಪರಿಚಯದೊಂದಿಗೆ ನಾನು ಈಗಾಗಲೇ 300 ಕ್ಕೂ ಹೆಚ್ಚು ಪದಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿದ್ದೇನೆ, ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಹಂತಕ್ಕೆ ನೇರವಾಗಿ ಹೋಗುತ್ತೇವೆ.

ಏನು ಒಂದು ಬಫರ್ ಓವರ್ಫ್ಲೋ

ಇದಕ್ಕೆ ಉತ್ತರಿಸಲು ನಾವು ಮೊದಲು ಈ ಸಂಯೋಜನೆಯ ಮೊದಲಾರ್ಧವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.

ಬಫರ್‌ಗಳು

ಎಲ್ಲವೂ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಮೆಮೊರಿಯ ಬಗ್ಗೆ ಇರುವುದರಿಂದ, ಕೆಲವು ರೀತಿಯ ಮಾಹಿತಿ ಧಾರಕ ಇರಬೇಕು ಎಂಬುದು ತಾರ್ಕಿಕವಾಗಿದೆ. ನಾವು ಮಾತನಾಡುವಾಗ ಒಳಹರಿವು o ಫಲಿತಾಂಶಗಳು, ನಾವು ನೇರವಾಗಿ ಪರಿಕಲ್ಪನೆಗೆ ಬರುತ್ತೇವೆ ಬಫರ್ಗಳು. ಅದನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಎ ಬಫರ್ ಇದು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಗಾತ್ರದ ಮೆಮೊರಿ ಸ್ಥಳವಾಗಿದ್ದು, ಇದರಲ್ಲಿ ನಾವು ಮಾಹಿತಿಯ ಪ್ರಮಾಣವನ್ನು ಸಂಗ್ರಹಿಸಲಿದ್ದೇವೆ, ಸರಳ

ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಬಫರ್ ಅದನ್ನು ನಿಭಾಯಿಸಬಲ್ಲದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ತುಂಬಿದಾಗ ಉಕ್ಕಿ ಹರಿಯುತ್ತದೆ. ಆದರೆ ಇದು ಏಕೆ ಮುಖ್ಯ?

ಸ್ಟಾಕ್

ಸ್ಟ್ಯಾಕ್‌ಗಳು ಎಂದೂ ಕರೆಯಲ್ಪಡುವ ಅವು ಅಮೂರ್ತ ದತ್ತಾಂಶ ಪ್ರಕಾರವಾಗಿದ್ದು, ಇದರಲ್ಲಿ ನಾವು ಮಾಡಬಹುದು ಸ್ಟಾಕ್ ಮಾಹಿತಿ, ಅವರ ಮುಖ್ಯ ಲಕ್ಷಣವೆಂದರೆ ಅವರು ಆದೇಶವನ್ನು ಹೊಂದಿರುತ್ತಾರೆ LIFO (ಕೊನೆಯದಾಗಿ ಕೊನೆಯದು). ಫಲಕಗಳ ಸಂಗ್ರಹದ ಬಗ್ಗೆ ಒಂದು ಸೆಕೆಂಡ್ ಯೋಚಿಸೋಣ, ನಾವು ಅವುಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಮೇಲಕ್ಕೆ ಇಡುತ್ತೇವೆ, ಮತ್ತು ನಂತರ ನಾವು ಅವುಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಮೇಲಕ್ಕೆ ತೆಗೆಯುತ್ತೇವೆ, ಇದು ನಾವು ಹಾಕಿದ ಕೊನೆಯ ತಟ್ಟೆಯನ್ನು ಮಾಡುತ್ತದೆ (ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಒಂದು ) ನಾವು ಹೊರತೆಗೆಯಲಿರುವ ಮೊದಲ ಪ್ಲೇಟ್, ನಿಸ್ಸಂಶಯವಾಗಿ ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪ್ಲೇಟ್ ಅನ್ನು ಮಾತ್ರ ಹೊರತೆಗೆಯಲು ಸಾಧ್ಯವಾದರೆ ಮತ್ತು ಅದನ್ನು ಆ ಕ್ರಮದಲ್ಲಿ ಮಾಡಲು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ: ಪಿ.

ಈಗ ನೀವು ಈ ಎರಡು ಪರಿಕಲ್ಪನೆಗಳನ್ನು ತಿಳಿದಿದ್ದೀರಿ, ನಾವು ಅವುಗಳನ್ನು ಕ್ರಮವಾಗಿ ಇಡಬೇಕು. ಸ್ಟ್ಯಾಕ್‌ಗಳು ಮುಖ್ಯವಾದ ಕಾರಣ ನಾವು ನಡೆಸುವ ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಂ ತನ್ನದೇ ಆದದ್ದಾಗಿರುತ್ತದೆ ಮರಣದಂಡನೆ ಸ್ಟಾಕ್. ಆದರೆ ಈ ಸ್ಟಾಕ್ ಒಂದು ಹೊಂದಿದೆ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣ, ಕೆಳಗೆ ಬೆಳೆಯುತ್ತದೆ. ಇದರ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಏಕೈಕ ವಿಷಯವೆಂದರೆ, ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ಒಂದು ಕಾರ್ಯವನ್ನು ಕರೆಯುವಾಗ, ಸ್ಟಾಕ್ ಮೆಮೊರಿಯಲ್ಲಿನ X ಸಂಖ್ಯೆಯಿಂದ ಒಂದು ಸಂಖ್ಯೆಗೆ (Xn) ಹೋಗುತ್ತದೆ. ಆದರೆ ಮುಂದುವರಿಯಬೇಕಾದರೆ ನಾವು ಇನ್ನೊಂದು ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.

ಪಾಯಿಂಟರ್ಸ್

ಇದು ಸಿ ಜಗತ್ತಿನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿದಾಗ ಅನೇಕ ಪ್ರೋಗ್ರಾಮರ್ಗಳನ್ನು ಹುಚ್ಚರನ್ನಾಗಿ ಮಾಡುವ ಒಂದು ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ, ವಾಸ್ತವವಾಗಿ ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ದೊಡ್ಡ ಶಕ್ತಿಯು ಪಾಯಿಂಟರ್‌ಗಳ ಬಳಕೆಯಿಂದಾಗಿ. ಅದನ್ನು ಸರಳವಾಗಿಡಲು, ಪಾಯಿಂಟರ್ ಮೆಮೊರಿ ವಿಳಾಸವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಇದು ಸಂಕೀರ್ಣವಾಗಿದೆ, ಆದರೆ ಅದು ಅಷ್ಟು ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ, ನಾವೆಲ್ಲರೂ ನಮ್ಮ ಯಂತ್ರಗಳಲ್ಲಿ RAM ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ? ಸರಿ, ಇದನ್ನು ಎ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಬ್ಲಾಕ್ಗಳ ಸತತ ವ್ಯವಸ್ಥೆ, ಈ ಸ್ಥಳಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಸಂಖ್ಯೆಗಳಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ (0 ರಿಂದ 9 ರವರೆಗೆ ಮತ್ತು ನಂತರ A ನಿಂದ F ಗೆ, ಅಂದರೆ 0x0, 0x1, 0x6, 0xA, 0xF, 0x10). ಕುತೂಹಲಕಾರಿ ಟಿಪ್ಪಣಿಯಾಗಿ, 0x10 ಇಲ್ಲ ನಾವು ಅದನ್ನು ದಶಮಾಂಶ ಕ್ರಮಕ್ಕೆ ಪರಿವರ್ತಿಸಿದರೆ ಅದು 10 ಎಂದು ಹೇಳುವಂತೆಯೇ ಇರುತ್ತದೆ. ಇದು ಮೊದಲಿಗೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಗೊಂದಲಗಳನ್ನುಂಟು ಮಾಡುತ್ತದೆ, ಆದರೆ ಅದಕ್ಕೆ ಇಳಿಯೋಣ.

ದಾಖಲೆಗಳು

ಪ್ರೊಸೆಸರ್ಗಳು ಹಲವಾರು ಕೆಲಸ ಮಾಡುತ್ತವೆ ದಾಖಲೆಗಳು, ಇದು ಭೌತಿಕ ಸ್ಮರಣೆಯಿಂದ ಪ್ರೊಸೆಸರ್‌ಗೆ ಸ್ಥಳಗಳನ್ನು ರವಾನಿಸಲು ಕೆಲಸ ಮಾಡುತ್ತದೆ, 64-ಬಿಟ್‌ಗಳನ್ನು ಬಳಸುವ ವಾಸ್ತುಶಿಲ್ಪಗಳಿಗಾಗಿ, ರೆಜಿಸ್ಟರ್‌ಗಳ ಸಂಖ್ಯೆ ದೊಡ್ಡದಾಗಿದೆ ಮತ್ತು ಇಲ್ಲಿ ವಿವರಿಸಲು ಕಷ್ಟ, ಆದರೆ ಕಲ್ಪನೆಯನ್ನು ಪಡೆಯಲು, ರೆಜಿಸ್ಟರ್‌ಗಳು ಪಾಯಿಂಟರ್‌ಗಳಂತೆ ಇರುತ್ತವೆ, ಅವು ಇತರ ವಿಷಯಗಳ ಬಗ್ಗೆ ಸೂಚಿಸುತ್ತವೆ , ಮೆಮೊರಿ ಸ್ಥಳ (ಸ್ಥಳ).

ಈಗ ಅಭ್ಯಾಸ ಮಾಡಿ

ಇದುವರೆಗೂ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಕಷ್ಟು ಮಾಹಿತಿಗಳಿವೆ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ವಾಸ್ತವದಲ್ಲಿ ಅವು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣವಾದ ಸಮಸ್ಯೆಗಳಾಗಿದ್ದು, ನಾನು ಅದನ್ನು ಸರಳ ರೀತಿಯಲ್ಲಿ ವಿವರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ, ನಾವು ಬಫರ್‌ಗಳನ್ನು ಬಳಸುವ ಒಂದು ಸಣ್ಣ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನೋಡಲಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಹೋಗುತ್ತಿದ್ದೇವೆ ಓವರ್‌ಫ್ಲೋಗಳ ಬಗ್ಗೆ ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅದನ್ನು ಮುರಿಯಿರಿ, ನಿಸ್ಸಂಶಯವಾಗಿ ಇದು ನಿಜವಾದ ಪ್ರೋಗ್ರಾಂ ಅಲ್ಲ, ಮತ್ತು ನಾವು ಇಂದು ಬಳಸಲಾಗುವ ಅನೇಕ ಪ್ರತಿಕ್ರಮಗಳನ್ನು "ತಪ್ಪಿಸಲು" ಹೋಗುತ್ತೇವೆ, ಮೊದಲು ಹೇಗೆ ಕಾರ್ಯಗಳನ್ನು ಮಾಡಲಾಯಿತು ಎಂಬುದನ್ನು ತೋರಿಸಲು 🙂 ಮತ್ತು ಇವುಗಳಲ್ಲಿ ಕೆಲವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ವಿಷಯಗಳನ್ನು ಕಲಿಯಲು ತತ್ವಗಳು ಅವಶ್ಯಕ

ಜಿಡಿಬಿ

ನಿಸ್ಸಂದೇಹವಾಗಿ ಸಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಹೆಚ್ಚು ಬಳಸುತ್ತಿರುವ ಒಂದು ಉತ್ತಮ ಪ್ರೋಗ್ರಾಂ. ಅದರ ಅನೇಕ ಸದ್ಗುಣಗಳಲ್ಲಿ ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಮಾತನಾಡುತ್ತಿರುವ, ರೆಜಿಸ್ಟರ್‌ಗಳು, ಸ್ಟಾಕ್, ಬಫರ್‌ಗಳು ಇತ್ಯಾದಿಗಳ ಬಗ್ಗೆ ನೋಡಲು ಇದು ನಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ ಎಂಬ ಅಂಶವನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ ನಮ್ಮ ಉದಾಹರಣೆಗಾಗಿ ನಾವು ಬಳಸಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನೋಡೋಣ.

retinput.c

ಇದು ಸಾಕಷ್ಟು ಸರಳವಾದ ಕಾರ್ಯಕ್ರಮ, ನಾವು ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸಲಿದ್ದೇವೆ stdio.h ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಎಂಬ ಕಾರ್ಯವನ್ನು ನಾವು ನೋಡಬಹುದು return_input ಇದು ಉತ್ಪಾದಿಸುತ್ತದೆ ಬಫರ್ ಕರೆಯಲಾಗುತ್ತದೆ ಸರಣಿ, ಇದು 30 ಉದ್ದವನ್ನು ಹೊಂದಿದೆ ಬೈಟ್ಗಳು (ಚಾರ್ ಡೇಟಾ ಪ್ರಕಾರವು 1 ಬೈಟ್ ಉದ್ದವಾಗಿದೆ).

ಕಾರ್ಯ gets(array); ಕನ್ಸೋಲ್ ಮತ್ತು ಕಾರ್ಯದ ಮೂಲಕ ಮಾಹಿತಿಯನ್ನು ವಿನಂತಿಸಿ printf() ರಚನೆಯ ವಿಷಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಸಿ ಯಲ್ಲಿ ಬರೆಯಲಾದ ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ main(), ಇದು ರಿಟರ್ನ್_ಇನ್‌ಪುಟ್‌ಗೆ ಕರೆ ಮಾಡುವ ಉಸ್ತುವಾರಿ ಮಾತ್ರ ಇರುತ್ತದೆ, ಈಗ ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲಿದ್ದೇವೆ.

ನಾನು ಈಗ ಮಾಡಿದ್ದನ್ನು ಸ್ವಲ್ಪ ತೆಗೆದುಕೊಳ್ಳೋಣ. ಆಯ್ಕೆ -ggdb ಸರಿಯಾಗಿ ಡೀಬಗ್ ಮಾಡಲು ಜಿಡಿಬಿಗೆ ಮಾಹಿತಿಯೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಬೇಕೆಂದು ಜಿಸಿಗೆ ಹೇಳುತ್ತದೆ. -fno-stack-protector ಇದು ನಿಸ್ಸಂಶಯವಾಗಿ ನಾವು ಬಳಸಬಾರದು, ಆದರೆ ನಾವು ಬಳಸಲಿದ್ದೇವೆ ಏಕೆಂದರೆ ಇಲ್ಲದಿದ್ದರೆ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಬಫರ್ ಓವರ್‌ಫ್ಲೋ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಿದೆ. ಕೊನೆಯಲ್ಲಿ ನಾನು ಫಲಿತಾಂಶವನ್ನು ಪರೀಕ್ಷಿಸಿದ್ದೇನೆ. ./a.out ಅದು ನಾನು ಸಂಗ್ರಹಿಸಿದದನ್ನು ನಡೆಸುತ್ತದೆ, ಅದು ನನಗೆ ಮಾಹಿತಿಯನ್ನು ಕೇಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಚಾಲನೆಯಲ್ಲಿದೆ

ಎಚ್ಚರಿಕೆಗಳು

ಇಲ್ಲಿ ಮತ್ತೊಂದು ಟಿಪ್ಪಣಿ. ನೀವು ಎಚ್ಚರಿಕೆಗಳನ್ನು ನೋಡಬಹುದೇ? ನಾವು ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಅಥವಾ ಕಂಪೈಲ್ ಮಾಡುವಾಗ ಇದು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಸಂಗತಿಯಾಗಿದೆ, ಇದು ಸ್ವಲ್ಪ ಸ್ಪಷ್ಟವಾಗಿದೆ ಮತ್ತು ಇಂದು ಕಾರ್ಯವನ್ನು ಹೊಂದಿರುವ ಕೆಲವು ಕಾರ್ಯಕ್ರಮಗಳಿವೆ gets() ಕೋಡ್‌ನಲ್ಲಿ. ಜೆಂಟೂನ ಒಂದು ಪ್ರಯೋಜನವೆಂದರೆ, ಪ್ರತಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮೂಲಕ, ನಾನು ತಪ್ಪಾಗಿರಬಹುದೆಂದು ನೋಡಬಹುದು, "ಆದರ್ಶ" ಪ್ರೋಗ್ರಾಂ ಅವುಗಳನ್ನು ಹೊಂದಿರಬಾರದು, ಆದರೆ ಈ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಎಷ್ಟು ದೊಡ್ಡ ಪ್ರೋಗ್ರಾಂಗಳು ಹೊಂದಿವೆ ಎಂದು ನಿಮಗೆ ಆಶ್ಚರ್ಯವಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅವು ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಮತ್ತು ಅದು ಅವುಗಳನ್ನು ಗಮನದಲ್ಲಿರಿಸಿಕೊಳ್ಳುವುದು ಕಷ್ಟ. ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಎಚ್ಚರಿಕೆಗಳು ಇದ್ದಾಗ ಅಪಾಯಕಾರಿ ಕಾರ್ಯಗಳು. ಈಗ ನಾವು ಮುಂದುವರಿಸಿದರೆ

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಈಗ ಈ ಭಾಗವು ಸ್ವಲ್ಪ ಗೊಂದಲಕ್ಕೊಳಗಾಗಬಹುದು, ಆದರೆ ನಾನು ಈಗಾಗಲೇ ಸಾಕಷ್ಟು ಬರೆದಿದ್ದರಿಂದ, ಎಲ್ಲವನ್ನೂ ವಿವರಿಸಲು ನನಗೆ ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ತುಂಬಾ ವೇಗವಾಗಿ ಹೋಗುತ್ತಿದ್ದೇನೆ ಎಂದು ನೀವು ನೋಡಿದರೆ ಕ್ಷಮಿಸಿ

ಕೋಡ್ ಅನ್ನು ನಿಶ್ಯಸ್ತ್ರಗೊಳಿಸುವುದು

ನಮ್ಮ ಸಂಕಲಿಸಿದ ಯಂತ್ರ ಭಾಷಾ ಕಾರ್ಯಕ್ರಮವನ್ನು ನೋಡುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣ.

ಇದು ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯದ ಸಂಕೇತವಾಗಿದೆ ಅಸೆಂಬ್ಲಿ, ನಮ್ಮ ಪ್ರೊಸೆಸರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಇದನ್ನೇ, ಎಡಭಾಗದಲ್ಲಿರುವ ರೇಖೆಯು ಮೆಮೊರಿಯಲ್ಲಿರುವ ಭೌತಿಕ ವಿಳಾಸ, ದಿ <+ n> ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಆಫ್ಸೆಟ್, ಮೂಲತಃ ಕ್ರಿಯೆಯ ಪ್ರಾರಂಭದಿಂದ (ಮುಖ್ಯ) ಆ ಹೇಳಿಕೆಗೆ ಇರುವ ದೂರ (ಇದನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಆಪ್ಕೋಡ್). ನಂತರ ನಾವು ಸೂಚನೆಯ ಪ್ರಕಾರವನ್ನು (ಪುಶ್ / ಮೂವ್ / ಕಾಲ್ಕ್…) ಮತ್ತು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ನೋಡುತ್ತೇವೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ ಅದು ಮೂಲ / ಮೂಲ ಮತ್ತು ಗಮ್ಯಸ್ಥಾನವನ್ನು ಅನುಸರಿಸುವ ಸೂಚನೆಯಾಗಿದೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು. <return_input> ನಮ್ಮ ಎರಡನೇ ಕಾರ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ನೋಡೋಣ.

ರಿಟರ್ನ್_ಇನ್‌ಪುಟ್

ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ, ಆದರೆ ನೀವು ಒಂದೆರಡು ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ, ಟ್ಯಾಗ್ ಇದೆ <gets@plt> ಮತ್ತು ಕೊನೆಯ ಆಪ್ಕೋಡ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ retq ಕಾರ್ಯದ ಅಂತ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಾವು ಒಂದೆರಡು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಹಾಕಲಿದ್ದೇವೆ, ಒಂದು ಕಾರ್ಯದಲ್ಲಿ gets ಮತ್ತು ಇನ್ನೊಂದು retq.

ರನ್

ಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಈಗ ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲಿದ್ದೇವೆ.

ನಾವು ಇರುವ ಆಪ್ಕೋಡ್ ಅನ್ನು ಸೂಚಿಸುವ ಸಣ್ಣ ಬಾಣವು ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನಾವು ನೋಡಬಹುದು, ಅವರು ದಿಕ್ಕನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ 0x000055555555469b, ಕರೆ ಮಾಡಿದ ನಂತರ ಇದು ವಿಳಾಸವಾಗಿದೆ return_input ಕಾರ್ಯದಲ್ಲಿದೆ main , ಇದು ಮುಖ್ಯವಾದುದು ಏಕೆಂದರೆ ನೀವು ಸ್ವೀಕರಿಸುವಾಗ ಪ್ರೋಗ್ರಾಂ ಹಿಂತಿರುಗಬೇಕು ಇನ್ಪುಟ್, ಕಾರ್ಯಕ್ಕೆ ಹೋಗೋಣ. ಈಗ ನಾವು ಕಾರ್ಯವನ್ನು ಪ್ರವೇಶಿಸುವ ಮೊದಲು ಮೆಮೊರಿಯನ್ನು ಪರಿಶೀಲಿಸಲಿದ್ದೇವೆ gets.

ನಾನು ನಿಮಗಾಗಿ ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಮತ್ತೆ ಇರಿಸಿದ್ದೇನೆ ಮತ್ತು ನೀವು ಉಲ್ಲೇಖಿಸಿರುವ ಕೋಡ್ ಅನ್ನು ನಾನು ಹೈಲೈಟ್ ಮಾಡಿದ್ದೇನೆ, ನೀವು ನೋಡುವಂತೆ, ಸಹಿಷ್ಣುತೆ ಎರಡು ಭಾಗಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ, ಅವರು ನಿರ್ದೇಶನವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ 0x7fffffffdbf0 (ಕಮಾಂಡೋ ನಂತರ ಎಡದಿಂದ ಮೊದಲನೆಯದು x/20x $rsp) ಗಳಿಕೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ಬಳಸಬೇಕಾದ ಸ್ಥಳ ಇದಾಗಿರುವುದರಿಂದ, ಮುಂದುವರಿಸೋಣ:

ಕಾರ್ಯಕ್ರಮವನ್ನು ಮುರಿಯುವುದು

ನಾನು ಅವುಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡಿದ್ದೇನೆ 0x44444444ಏಕೆಂದರೆ ಅವು ನಮ್ಮ ಡಿಎಸ್‌ನ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ-ಈಗ ನಾವು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ ಇನ್ಪುಟ್ ಪ್ರೋಗ್ರಾಂಗೆ, ಮತ್ತು ನೀವು ನೋಡುವಂತೆ, ನಾವು ನಮ್ಮ ಅಪೇಕ್ಷಿತ ವಿಳಾಸದಿಂದ ಕೇವಲ ಎರಡು ಸಾಲುಗಳು, ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ನಾವು ಹೈಲೈಟ್ ಮಾಡಿದ ವಿಳಾಸಗಳಿಗೆ ಸ್ವಲ್ಪ ಮುಂಚೆಯೇ ನಾವು ಅದನ್ನು ಭರ್ತಿ ಮಾಡಲಿದ್ದೇವೆ.

ಹಿಂದಿರುಗುವ ಮಾರ್ಗವನ್ನು ಬದಲಾಯಿಸುವುದು

ಈಗ ನಾವು ಕೋಡ್‌ನ ಈ ವಿಭಾಗವನ್ನು ನಮೂದಿಸುವಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿದ್ದೇವೆ, ಅದು ಕಾರ್ಯದ ಹಿಂತಿರುಗುವಿಕೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ನಾವು ವಿಳಾಸವನ್ನು ಬದಲಾಯಿಸಿದರೆ ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ a ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ಹಿಂದೆ ಹೊಂದಿದ್ದ ಆಪ್‌ಕೋಡ್‌ನ ಸ್ಥಳಕ್ಕೆ ಹೋಗುವ ಬದಲು ನಾವು ಹಿಂತಿರುಗಿ ಹೋದರೆ ನಿಮ್ಮ ಅಭಿಪ್ರಾಯವೇನು? return_input? ಆದರೆ ಇದಕ್ಕಾಗಿ, ಬೈನರಿಯಲ್ಲಿ ನಮಗೆ ಬೇಕಾದ ವಿಳಾಸವನ್ನು ಬರೆಯುವುದು ಅವಶ್ಯಕ, ನಾವು ಅದನ್ನು ಕಾರ್ಯದೊಂದಿಗೆ ಮಾಡಲಿದ್ದೇವೆ printf ಬ್ಯಾಷ್ನಿಂದ

ಈಗ ನಾವು ಎರಡು ಬಾರಿ ಮಾಹಿತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ-ಖಂಡಿತವಾಗಿಯೂ ಅದಕ್ಕಾಗಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮಾಡಲಾಗಿಲ್ಲ, ಆದರೆ ನಾವು ಕೋಡ್ ಅನ್ನು ಮುರಿಯಲು ಮತ್ತು ಅದನ್ನು ಮಾಡಬೇಕಾಗಿಲ್ಲದ ಯಾವುದನ್ನಾದರೂ ಪುನರಾವರ್ತಿಸುವಂತೆ ಮಾಡಲು ಯಶಸ್ವಿಯಾಗಿದ್ದೇವೆ.

ಪ್ರತಿಫಲನಗಳು

ಈ ಸರಳ ಬದಲಾವಣೆಯನ್ನು ಎ ಎಂದು ಪರಿಗಣಿಸಬಹುದು ದುರ್ಬಳಕೆ ಮಾಡಿ ಅತ್ಯಂತ ಮೂಲಭೂತವಾದದ್ದು-ಅವರು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮುರಿಯಲು ಮತ್ತು ಅವರು ಏನನ್ನಾದರೂ ಮಾಡಲು ನಾವು ಬಯಸಿದ್ದೇವೆ.

ನೋಡಲು ಮತ್ತು ಸೇರಿಸಲು ಬಹುತೇಕ ಅನಂತ ವಸ್ತುಗಳ ಪಟ್ಟಿಯಲ್ಲಿ ಇದು ಕೇವಲ ಮೊದಲ ಹೆಜ್ಜೆಯಾಗಿದೆ, ಆದೇಶವನ್ನು ಪುನರಾವರ್ತಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ವಿಷಯಗಳನ್ನು ಸೇರಿಸಲು ಮಾರ್ಗಗಳಿವೆ, ಆದರೆ ಈ ಸಮಯದಲ್ಲಿ ನಾನು ಬಹಳಷ್ಟು ಬರೆದಿದ್ದೇನೆ ಮತ್ತು ಅದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲವೂ ಶೆಲ್ಕೋಡಿಂಗ್ ಲೇಖನಗಳಿಗಿಂತ ಹೆಚ್ಚಿನದನ್ನು ಬರೆಯುವುದು ಒಂದು ವಿಷಯ, ನಾನು ಹೇಳುವ ಸಂಪೂರ್ಣ ಪುಸ್ತಕಗಳು. ನಾನು ಇಷ್ಟಪಟ್ಟ ವಿಷಯಗಳ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅಧ್ಯಯನ ಮಾಡಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಕ್ಷಮಿಸಿ, ಆದರೆ ಖಂಡಿತವಾಗಿಯೂ ಅವಕಾಶವಿರುತ್ತದೆ 🙂 ಶುಭಾಶಯಗಳು ಮತ್ತು ಇಲ್ಲಿಗೆ ಬಂದಿದ್ದಕ್ಕಾಗಿ ಧನ್ಯವಾದಗಳು.