ಹೆಲ್ಮ್‌ಹೋಲ್ಟ್ಜ್ ಸೆಂಟರ್ ಫಾರ್ ಇನ್‌ಫರ್ಮೇಷನ್ ಸೆಕ್ಯುರಿಟಿ (CISPA) ಮತ್ತು ರಾಯಲ್ ಇನ್‌ಸ್ಟಿಟ್ಯೂಟ್ ಆಫ್ ಟೆಕ್ನಾಲಜಿ (ಸ್ವೀಡನ್) ನ ಸಂಶೋಧಕರು Node.js ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು ಅದರ ಆಧಾರದ ಮೇಲೆ ಜನಪ್ರಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಮೇಲೆ ದಾಳಿಗಳನ್ನು ರಚಿಸಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಮಾದರಿಯ ಮಾಲಿನ್ಯ ತಂತ್ರದ ಅನ್ವಯಿಸುವಿಕೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿದ್ದಾರೆ, ಇದು ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್‌ಗೆ ಕಾರಣವಾಯಿತು.
ಮೂಲಮಾದರಿಯ ಮಾಲಿನ್ಯ ವಿಧಾನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಸುತ್ತದೆ ಅದು ಯಾವುದೇ ವಸ್ತುವಿನ ಮೂಲ ಮಾದರಿಗೆ ಹೊಸ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕೋಡ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು (ಗ್ಯಾಜೆಟ್‌ಗಳು) ಒಳಗೊಂಡಿರಬಹುದು, ಅದರ ಕಾರ್ಯಾಚರಣೆಯು ಬದಲಿ ಆಸ್ತಿಯಿಂದ ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ; ಉದಾಹರಣೆಗೆ, ಕೋಡ್ 'const cmd = options.cmd || "/bin/sh"', ಆಕ್ರಮಣಕಾರರು ಮೂಲ ಮೂಲಮಾದರಿಯಲ್ಲಿ "cmd" ಆಸ್ತಿಯನ್ನು ಬದಲಿಸಲು ನಿರ್ವಹಿಸಿದರೆ ಅದರ ತರ್ಕವನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.
ಒಂದು ಯಶಸ್ವಿ ದಾಳಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ವಸ್ತುವಿನ ಮೂಲ ಮೂಲಮಾದರಿಯಲ್ಲಿ ಹೊಸ ಆಸ್ತಿಯನ್ನು ರಚಿಸಲು ಬಾಹ್ಯ ಡೇಟಾವನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಆ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಮಾರ್ಪಡಿಸಿದ ಆಸ್ತಿಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಗ್ಯಾಜೆಟ್ ಅನ್ನು ಎದುರಿಸುತ್ತದೆ. Node.js ನಲ್ಲಿ "__proto__" ಮತ್ತು "ಕನ್ಸ್ಟ್ರಕ್ಟರ್" ಸೇವಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದರ ಮೂಲಕ ಮೂಲಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸುವುದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ. "__proto__" ಆಸ್ತಿಯು ವಸ್ತುವಿನ ವರ್ಗದ ಮೂಲಮಾದರಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು "ಕನ್ಸ್ಟ್ರಕ್ಟರ್" ಆಸ್ತಿಯು ವಸ್ತುವನ್ನು ರಚಿಸಲು ಬಳಸಿದ ಕಾರ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ "obj[a][b] = ಮೌಲ್ಯ" ನಿಯೋಜನೆಯನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಬಾಹ್ಯ ಡೇಟಾದಿಂದ ಹೊಂದಿಸಿದ್ದರೆ, ಆಕ್ರಮಣಕಾರರು "__proto__" ಮೌಲ್ಯಕ್ಕೆ "a" ಅನ್ನು ಹೊಂದಿಸಬಹುದು ಮತ್ತು ಅವರ ಸ್ವಂತ ಆಸ್ತಿಯ ಸ್ಥಾಪನೆಯನ್ನು ಸಾಧಿಸಬಹುದು. "b" ಹೆಸರಿನೊಂದಿಗೆ ಮತ್ತು ವಸ್ತುವಿನ ಮೂಲ ಮಾದರಿಯಲ್ಲಿ "ಮೌಲ್ಯ" ಮೌಲ್ಯದೊಂದಿಗೆ (obj.__proto__.b = ಮೌಲ್ಯ;), ಮತ್ತು ಮೂಲಮಾದರಿಯಲ್ಲಿ ಹೊಂದಿಸಲಾದ ಆಸ್ತಿಯು ಎಲ್ಲಾ ವಸ್ತುಗಳಲ್ಲಿ ಗೋಚರಿಸುತ್ತದೆ. ಅದೇ ರೀತಿ, ಕೋಡ್ "obj[a][b][c] = value" ನಂತಹ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, "a" ಅನ್ನು "ಕನ್ಸ್ಟ್ರಕ್ಟರ್" ಮೌಲ್ಯಕ್ಕೆ ಮತ್ತು "b" ಅನ್ನು "ಮೂಲಮಾದರಿ" ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಎಲ್ಲಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ, ನೀವು ಮಾಡಬಹುದು "ಸಿ" ಹೆಸರಿನೊಂದಿಗೆ ಹೊಸ ಆಸ್ತಿಯನ್ನು ಮತ್ತು "ಮೌಲ್ಯ" ಮೌಲ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.
ಮೂಲಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸುವ ಉದಾಹರಣೆ: const o1 = {}; const o2 = ಹೊಸ ವಸ್ತು (); o1.__proto__.x = 42; // ರೂಟ್ ಪ್ರೊಟೊಟೈಪ್ console.log (o2.x) ನಲ್ಲಿ "x" ಆಸ್ತಿಯನ್ನು ರಚಿಸಿ; // ಇನ್ನೊಂದು ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದ “x” ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಿ // ಔಟ್‌ಪುಟ್ 42 ಆಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ ಮೂಲ ಮೂಲಮಾದರಿಯು ಆಬ್ಜೆಕ್ಟ್ o1 ಮೂಲಕ ಬದಲಾಗಿದೆ, ಇದನ್ನು ಆಬ್ಜೆಕ್ಟ್ o2 ನಲ್ಲಿಯೂ ಬಳಸಲಾಗುತ್ತದೆ
ದುರ್ಬಲ ಕೋಡ್‌ನ ಉದಾಹರಣೆ: ಫಂಕ್ಷನ್ ಎಂಟ್ರಿಪಾಯಿಂಟ್ (arg1, arg2, arg3){const obj = {}; const p = obj[arg1]; p[arg2] = arg3; ಹಿಂತಿರುಗಿ p; }
entryPoint ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಇನ್‌ಪುಟ್ ಡೇಟಾದಿಂದ ರೂಪುಗೊಂಡಿದ್ದರೆ, ಆಕ್ರಮಣಕಾರರು "__proto__" ಮೌಲ್ಯವನ್ನು arg1 ಗೆ ರವಾನಿಸಬಹುದು ಮತ್ತು ಮೂಲ ಮಾದರಿಯಲ್ಲಿ ಯಾವುದೇ ಹೆಸರಿನೊಂದಿಗೆ ಆಸ್ತಿಯನ್ನು ರಚಿಸಬಹುದು. ನೀವು arg2 ಮೌಲ್ಯವನ್ನು "toString" ಮತ್ತು arg3 ಮೌಲ್ಯ 1 ಅನ್ನು ಹಾದು ಹೋದರೆ, ನೀವು "toString" ಆಸ್ತಿಯನ್ನು (Object.prototype.toString=1) ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು toString() ಗೆ ಕರೆ ಮಾಡುವಾಗ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡಬಹುದು.
"ಮುಖ್ಯ", "ಶೆಲ್", "ರಫ್ತು", "ಸಂದರ್ಭ ವಿಸ್ತರಣೆಗಳು" ಮತ್ತು "env" ಗುಣಲಕ್ಷಣಗಳ ರಚನೆಯು ಆಕ್ರಮಣಕಾರರ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್‌ಗೆ ಕಾರಣವಾಗುವ ಸಂದರ್ಭಗಳ ಉದಾಹರಣೆಗಳಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, ಆಕ್ರಮಣಕಾರನು ವಸ್ತುವಿನ ಮೂಲ ಮಾದರಿಯಲ್ಲಿ "ಮುಖ್ಯ" ಆಸ್ತಿಯನ್ನು ರಚಿಸಬಹುದು, ಅದರಲ್ಲಿ ತನ್ನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಬರೆಯಬಹುದು (Object.prototype.main = "./../../pwned.js") ಮತ್ತು ಒಳಗೊಂಡಿರುವ ಪ್ಯಾಕೇಜ್ ಪ್ಯಾಕೇಜ್.json ನಲ್ಲಿ "ಮುಖ್ಯ" ಆಸ್ತಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ (ಆಸ್ತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ, ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅವಶ್ಯಕತೆ ("ನನ್ನ-ಪ್ಯಾಕೇಜ್") ಕೋಡ್‌ನಲ್ಲಿ ಈ ಆಸ್ತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ. ಇದನ್ನು ಮೂಲ ಮಾದರಿಯಿಂದ ಪಡೆಯಲಾಗುತ್ತದೆ). "ಶೆಲ್", "ರಫ್ತುಗಳು" ಮತ್ತು "env" ಗುಣಲಕ್ಷಣಗಳನ್ನು ಇದೇ ರೀತಿ ಬದಲಿಸಬಹುದು: rootProto = Object.prototype ಅನ್ನು ಅನುಮತಿಸಿ; rootProto["exports"] = {".":"./changelog.js"}; rootProto["1"] = "/path/to/npm/scripts/"; // ಟ್ರಿಗರ್ ಕರೆ ಅಗತ್ಯವಿದೆ("./target.js"); Object.prototype.main = "/path/to/npm/scripts/changelog.js"; Object.prototype.shell = "ನೋಡ್"; Object.prototype.env = {}; Object.prototype.env.NODE_OPTIONS = "—inspect-brk=0.0.0.0:1337"; // ಟ್ರಿಗರ್ ಕರೆ ಅಗತ್ಯವಿದೆ ("ಬೈಟ್‌ಗಳು");
ಸಂಶೋಧಕರು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ 10 NPM ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿದ್ದಾರೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ 1958 ಪ್ಯಾಕೇಜ್.json ನಲ್ಲಿ ಮುಖ್ಯ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿಲ್ಲ, 4420 ತಮ್ಮ ಅಗತ್ಯ ಹೇಳಿಕೆಗಳಲ್ಲಿ ಸಂಬಂಧಿತ ಮಾರ್ಗಗಳನ್ನು ಬಳಸುತ್ತಾರೆ ಮತ್ತು 355 ನೇರವಾಗಿ ಕಮಾಂಡ್ ಪರ್ಯಾಯ API ಅನ್ನು ಬಳಸುತ್ತಾರೆ.
ಎವಾಲ್‌ಫಂಕ್ಷನ್‌ಗಳ ಆಸ್ತಿಯನ್ನು ಅತಿಕ್ರಮಿಸುವ ಪಾರ್ಸ್ ಸರ್ವರ್ ಬ್ಯಾಕೆಂಡ್‌ನ ಮೇಲೆ ದಾಳಿ ಮಾಡಲು ಒಂದು ಕಾರ್ಯಾಚರಣೆಯ ಉದಾಹರಣೆಯಾಗಿದೆ. ಅಂತಹ ದುರ್ಬಲತೆಗಳ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಸರಳಗೊಳಿಸಲು, ಸ್ಥಿರ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ವಿಶ್ಲೇಷಣಾ ವಿಧಾನಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಟೂಲ್ಕಿಟ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. Node.js ನ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ, ಆಕ್ರಮಣಕಾರರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾಗುವ ದಾಳಿಗಳನ್ನು ಸಂಘಟಿಸಲು ಬಳಸಬಹುದಾದ 11 ಗ್ಯಾಜೆಟ್‌ಗಳನ್ನು ಗುರುತಿಸಲಾಗಿದೆ. ಪಾರ್ಸ್ ಸರ್ವರ್ ಜೊತೆಗೆ, NPM CLI ನಲ್ಲಿ ಎರಡು ಶೋಷಣೆಯ ದೋಷಗಳನ್ನು ಸಹ ಗುರುತಿಸಲಾಗಿದೆ.
ಮೂಲ: opennet.ru