ਰੂਟਕਿਟ ਕੀ ਹੈ?
ਰੂਟਕਿਟ ਹੁਣ ਸਿਰਫ਼ ਹੇਠਲੇ ਪੱਧਰ ਦਾ ਮਾਲਵੇਅਰ ਨਹੀਂ ਹੈ। ਇਸਦੇ ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਹ ਗੁਪਤ ਹੈ ਮਾਲਵੇਅਰ ਜੋ ਅਣਅਧਿਕਾਰਤ ਪਹੁੰਚ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਆਪਣੀ ਹੋਂਦ ਨੂੰ ਲੁਕਾਉਂਦੇ ਹੋਏ। ਰਵਾਇਤੀ ਸੰਦਰਭਾਂ ਵਿੱਚ, ਰੂਟਕਿਟਸ ਕਰਨਲ ਸਪੇਸ ਜਾਂ ਸਿਸਟਮ ਸੇਵਾਵਾਂ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਅੱਜ, ਉਹ ਤੁਹਾਡੇ ਰਿਪੋਜ਼ਟਰੀਆਂ, CI ਸਿਸਟਮਾਂ ਅਤੇ ਪੈਕੇਜ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਵੀ ਰਹਿੰਦੇ ਹਨ, ਸਾਦੀ ਨਜ਼ਰ ਵਿੱਚ ਲੁਕਦੇ ਹਨ, ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਨਾਲ ਛੇੜਛਾੜ ਕਰਦੇ ਹਨ, ਅਤੇ ਬਿਲਡ ਸਿਸਟਮਾਂ ਨੂੰ ਸੰਕਰਮਿਤ ਕਰਦੇ ਹਨ।
ਸਿਸਟਮ ਰੂਟਕਿਟਸ ਤੋਂ ਰਿਪੋਜ਼ਟਰੀ ਰੂਟਕਿਟਸ ਤੱਕ
ਸਿਸਟਮ ਇੰਜੀਨੀਅਰ ਕਰਨਲ ਰੂਟਕਿੱਟਾਂ 'ਤੇ ਪਸੀਨਾ ਵਹਾਉਂਦੇ ਸਨ। ਇਹਨਾਂ ਨੇ ਸਿਸਟਮ 'ਤੇ ਪੂਰਾ ਨਿਯੰਤਰਣ ਦਿੱਤਾ, ਸਿਸਟਮਕਾਲਾਂ ਨੂੰ ਰੋਕਿਆ, ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਲੁਕਾਇਆ, ਅਤੇ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਸਮਝੌਤਾ ਕੀਤਾ। ਹੁਣ, ਇੱਕ ਡਿਵੈਲਪਰ-ਕੇਂਦ੍ਰਿਤ ਦ੍ਰਿਸ਼ ਮੰਨ ਲਓ: ਇੱਕ ਖਤਰਨਾਕ ਐਕਟਰ ਤੁਹਾਡੇ ਵਿੱਚ ਇੱਕ ਰੂਟਕਿੱਟ ਇੰਜੈਕਟ ਕਰਦਾ ਹੈ Git ਰੈਪੋ or ਨਿਰਭਰਤਾ ਰੁੱਖ. ਇਹ ਰਿਪੋਜ਼ਟਰੀ ਰੂਟਕਿੱਟ ਇੱਕ ਕੋਡ ਹੈ ਜੋ ਤੁਹਾਡੇ ਬਿਲਡ ਆਉਟਪੁੱਟ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਦਾ ਹੈ ਜਾਂ ਬੈਕਡੋਰ ਵਿੱਚ ਘੁਸਪੈਠ ਕਰਦਾ ਹੈ, ਤੁਹਾਡੇ ਪੈਕੇਜ ਆਰਟੀਫੈਕਟਸ ਦਾ ਹਿੱਸਾ ਬਣ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੋਈ ਸਿਸਟਮ ਉਹਨਾਂ ਨੂੰ ਕਦੇ ਵੀ ਚਲਾਏ। ਰੂਟਕਿੱਟ ਤੁਹਾਡੇ ਸਰੋਤ, ਨਿਰਭਰਤਾਵਾਂ, ਅਤੇ ਵਿੱਚ ਅੱਪਸਟ੍ਰੀਮ ਸ਼ਿਫਟ ਕਰਦੇ ਹਨ। CI/CD ਵਹਿੰਦਾ ਹੈ।
ਰੂਟਕਿਟਸ ਕੋਡਬੇਸਾਂ ਅਤੇ ਨਿਰਭਰਤਾਵਾਂ ਵਿੱਚ ਕਿਵੇਂ ਲੁਕਦੇ ਹਨ
ਆਓ ਟੈਂਜਿਬਲ ਰੂਟਕਿਟ ਅਟੈਕ ਵੈਕਟਰਾਂ ਨੂੰ ਖੋਲ੍ਹੀਏ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਦੇਖਣੇ ਚਾਹੀਦੇ ਹਨ:
- ਅਸਪਸ਼ਟ ਜਾਂ ਗੁੰਮਰਾਹਕੁੰਨ commits
ਇੱਕ ਦੀ ਕਲਪਨਾ ਕਰੋ commit ਜੋ "ਫਿਕਸ ਟਾਈਪੋ" ਕਹਿੰਦਾ ਹੈ ਪਰ ਅਸਲ ਵਿੱਚ ਇੱਕ ਲੋਡਰ ਇੰਜੈਕਟ ਕਰਦਾ ਹੈ ਜੋ ਰਨਟਾਈਮ 'ਤੇ ਖਤਰਨਾਕ ਪੇਲੋਡਾਂ ਨੂੰ ਡੀਕ੍ਰਿਪਟ ਕਰਦਾ ਹੈ। ਰੂਟਕਿਟ ਖੋਜ ਮੁਸ਼ਕਲ ਹੁੰਦੀ ਹੈ ਜਦੋਂ commit ਸੁਨੇਹੇ ਇਰਾਦੇ ਨੂੰ ਲੁਕਾਉਂਦੇ ਹਨ। - ਬਦਲੀਆਂ ਹੋਈਆਂ ਜਾਂ ਪਿੱਛੇ ਵਾਲੇ ਦਰਵਾਜ਼ੇ ਵਾਲੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ
ਇੱਕ ਆਮ ਉਪਯੋਗਤਾ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਸੂਖਮ ਬੈਕਡੋਰਡ ਵਰਜਨ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਪਾਸ ਕਰਦਾ ਹੈ ਪਰ ਘੰਟਿਆਂ ਬਾਅਦ ਇੱਕ ਰਿਮੋਟ ਸਰਵਰ ਤੇ ਭੇਦ ਲੌਗ ਕਰਦਾ ਹੈ। ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਟੁੱਟ ਗਈ ਹੈ, ਭਾਵੇਂ ਲਾਇਬ੍ਰੇਰੀ ਜਾਣੀ-ਪਛਾਣੀ ਲੱਗਦੀ ਹੈ। - ਸਮਝੌਤਾ ਕੀਤੇ ਤੀਜੀ-ਧਿਰ ਪੈਕੇਜ ਅਤੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਿਰਭਰਤਾਵਾਂ
ਤੁਸੀਂ ਸਥਾਪਤ ਕੀਤਾ ਲਿਬ-ਕ੍ਰਿਪਟੋ@2.0.1; ਅੱਪਸਟ੍ਰੀਮ, ਕਿਸੇ ਨੇ ਜ਼ਹਿਰ ਦਿੱਤਾ ਹੋਇਆ ਵਰਜਨ 2.0.0 ਮਾਲਵੇਅਰ ਨਾਲ। ਹੁਣ ਤੁਹਾਡਾ pipeline ਗਲਤੀ ਨਾਲ ਰੂਟਕਿੱਟ ਖਿੱਚ ਲੈਂਦਾ ਹੈ, ਜਾਂ ਇਸ ਤੋਂ ਵੀ ਮਾੜੀ ਗੱਲ, ਤੁਹਾਡੀ ਲਾਕਫਾਈਲ ਡ੍ਰਾਈਫਟ ਹੋ ਗਈ ਅਤੇ ਤੁਸੀਂ ਦਾਗੀ ਕੋਡ ਖਿੱਚ ਲਿਆ। - ਸਲੀਪਿੰਗ ਕੋਡ ਅਤੇ ਲਾਜਿਕ ਬੰਬ
ਕੋਡ ਹਫ਼ਤਿਆਂ ਜਾਂ ਮਹੀਨਿਆਂ ਲਈ ਸਹਿਜ ਰਹਿੰਦਾ ਹੈ, ਫਿਰ ਜਾਗ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ:
ਅੱਜ ਟੈਸਟ ਪਾਸ ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਤੁਹਾਨੂੰ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਅਸਫਲ ਹੋਣ ਦਾ ਪਤਾ ਨਹੀਂ ਲੱਗਦਾ ਜਦੋਂ ਤੱਕ ਬਹੁਤ ਦੇਰ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।
DevOps ਵਿੱਚ ਰੂਟਕਿਟ ਖੋਜ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ
ਤੁਹਾਡੇ ਵਿੱਚ ਰੂਟਕਿਟਸ pipeline ਅਤੇ ਰਿਪੋਜ਼ ਅਸਲ ਡਿਵੈਲਪਰ ਵਰਕਫਲੋ ਨੂੰ ਧਮਕੀ ਦਿੰਦੇ ਹਨ:
- ਛੇੜਛਾੜ ਵਾਲੀਆਂ ਇਮਾਰਤਾਂ ਜੋ ਅਣਦੇਖੀਆਂ ਰਹਿ ਜਾਂਦੀਆਂ ਹਨ: ਜੇਕਰ ਇੱਕ ਰੂਟਕਿੱਟ hooks ਤੁਹਾਡੀ ਬਿਲਡ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਇੱਕ ਖਤਰਨਾਕ ਕਹੋ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ or setup.py, ਤੁਹਾਡਾ CI ਪਾਸ ਹੋ ਜਾਵੇਗਾ, ਅਤੇ ਤੁਸੀਂ ਬਿਨਾਂ ਜਾਣੇ ਸਮਝੌਤਾ ਕੀਤੇ ਕਲਾਕ੍ਰਿਤੀਆਂ ਨੂੰ ਧੱਕ ਦਿੰਦੇ ਹੋ।
- ਅਸੰਗਤ ਜਾਂ ਗੈਰ-ਪ੍ਰਜਨਨਯੋਗ ਨਿਰਮਾਣ: ਇੱਕ ਰੂਟਕਿੱਟ ਡਿਵੈਲਪਰ ਮਸ਼ੀਨਾਂ ਅਤੇ CI ਏਜੰਟਾਂ ਵਿੱਚ ਬਿਲਡਾਂ ਵਿੱਚ ਫ਼ਰਕ ਪਾ ਸਕਦੀ ਹੈ। ਇਹ ਫ਼ਰਕ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਲਈ ਇੱਕ ਲਾਲ ਝੰਡਾ ਹੈ, ਪਰ ਸਿਰਫ਼ ਤਾਂ ਹੀ ਜੇਕਰ ਤੁਸੀਂ ਇਸਦੀ ਜਾਂਚ ਕਰ ਰਹੇ ਹੋ।
- ਰਿਲੀਜ਼ਾਂ ਵਿੱਚ ਲਗਾਤਾਰ ਸਮਝੌਤਾ: ਇੱਕ ਵਾਰ ਏਮਬੈਡ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਇਹ ਬ੍ਰਾਂਚ ਮਰਜ, ਚੈਰੀ-ਪਿਕਸ, ਅਤੇ ਭਵਿੱਖੀ ਰਿਲੀਜ਼ਾਂ ਤੋਂ ਬਚ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਵੀ ਮਾੜੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇਹ ਆਪਣੇ ਆਪ ਨੂੰ ਅਪਡੇਟਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰ ਸਕਦਾ ਹੈ, ਤੁਹਾਡੀ ਸਪਲਾਈ ਚੇਨ ਨੂੰ ਖਰਾਬ ਕਰ ਸਕਦਾ ਹੈ।
- Pipeline ਡਿਵੈਲਪਰ ਵਾਤਾਵਰਣ ਦੇ ਅੰਦਰ ਜ਼ਹਿਰ ਅਤੇ ਪਾਸੇ ਦੀ ਗਤੀ: ਇੱਕ ਰੂਟਕਿੱਟ CI ਕੌਂਫਿਗ, ਸਾਂਝੇ ਰਨਰਸ, ਅਤੇ ਸਾਂਝੇ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਵਾਲੇ ਡਿਵੈਲਪਰ ਮਸ਼ੀਨਾਂ ਰਾਹੀਂ ਫੈਲ ਸਕਦੀ ਹੈ। ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਸਿਰਫ਼ ਕੋਡ ਵਿੱਚ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਵੀ ਭੰਗ ਹੁੰਦੀ ਹੈ।
ਵਿੱਚ ਵਿਹਾਰਕ ਰੂਟਕਿਟ ਖੋਜ Pipelines
ਤੁਹਾਡੀ ਰੂਟਕਿਟ ਖੋਜ ਗੇਮ ਨੂੰ ਵਧਾਉਣ ਲਈ ਇੱਥੇ ਡਿਵੈਲਪਰ-ਅਨੁਕੂਲ, ਕਾਰਵਾਈਯੋਗ ਤਕਨੀਕਾਂ ਹਨ:
• ਮਹੱਤਵਪੂਰਨ ਫਾਈਲਾਂ ਲਈ ਹੈਸ਼ ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਨਿਰਭਰਤਾ
ਮੁੱਖ ਫਾਈਲਾਂ ਲਈ ਇੱਕ SHA‑256 (ਜਾਂ ਸਮਾਨ) ਦੀ ਗਣਨਾ ਕਰੋ ਜਿਵੇਂ ਕਿ ਲੋੜਾਂ.txt, package-lock.json, ਜਾਂ ਉੱਚ-ਪੱਧਰੀ ਬਿਲਡ ਸਕ੍ਰਿਪਟਾਂ:
ਉਹਨਾਂ ਫਾਈਲਾਂ ਵਿੱਚ ਕੋਈ ਵੀ ਤਬਦੀਲੀ ਸੰਭਾਵੀ ਖਤਰਨਾਕ ਵਹਾਅ ਦਾ ਸੰਕੇਤ ਦਿੰਦੀ ਹੈ।
• SBOM (ਸਾਫਟਵੇਅਰ ਬਿੱਲ ਆਫ਼ ਮਟੀਰੀਅਲ) ਪ੍ਰਮਾਣਿਕਤਾ
ਤਿਆਰ SBOM Syft ਜਾਂ SPDX ਵਰਗੇ ਟੂਲਸ ਨਾਲ। ਤੁਹਾਡੇ ਬਿਲਡ ਵਿੱਚ ਕਿਹੜੀਆਂ ਨਿਰਭਰਤਾਵਾਂ (ਅਤੇ ਸੰਸਕਰਣ) ਹਨ, ਇਸਦਾ ਸਹੀ ਪਤਾ ਲਗਾਓ। ਤੁਲਨਾ ਕਰੋ। SBOMਅਣਕਿਆਸੇ ਜਾਂ ਖਤਰਨਾਕ ਜੋੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਬਿਲਡਾਂ ਵਿੱਚ s.
• ਦਸਤਖਤ ਕੀਤੇ commits ਅਤੇ ਦਸਤਖਤ ਤਸਦੀਕ
ਲਾਗੂ ਕਰੋ Git commit -S ਅਤੇ CI ਵਿੱਚ ਦਸਤਖਤਾਂ ਦੀ ਜਾਂਚ ਕਰੋ:
ਇੱਕ ਨਵਾਂ, ਬਿਨਾਂ ਦਸਤਖਤ ਕੀਤੇ, ਜਾਂ ਸ਼ੱਕੀ ਤੌਰ 'ਤੇ ਦਸਤਖਤ ਕੀਤੇ commit ਇੱਕ ਸਰੋਤ-ਰੂਟਕਿਟ ਪ੍ਰੋਬ ਹੋ ਸਕਦਾ ਹੈ।
• ਬਿਲਡ ਜਾਂ ਰਨਟਾਈਮ ਦੌਰਾਨ ਵਿਵਹਾਰ-ਅਧਾਰਤ ਵਿਗਾੜ ਦਾ ਪਤਾ ਲਗਾਉਣਾ
ਅਜੀਬ ਵਿਵਹਾਰ ਨੂੰ ਫੜਨ ਲਈ ਆਪਣੇ ਬਿਲਡ ਨੂੰ ਪ੍ਰੋਫਾਈਲਿੰਗ ਨਾਲ ਸੰਚਾਲਿਤ ਕਰੋ: ਉਦਾਹਰਨ ਲਈ, ਦੌਰਾਨ ਅਚਾਨਕ ਨੈੱਟਵਰਕ ਕਾਲਾਂ npm ਇੰਸਟਾਲ or ਪਾਈਪ ਇੰਸਟਾਲ ਕਰੋ, ਜਾਂ ਸੁਰੱਖਿਅਤ ਡਾਇਰਾਂ ਵਿੱਚ ਫਾਈਲ ਬਦਲਾਅ:
ਇੰਸਟਾਲੇਸ਼ਨ ਦੌਰਾਨ ਅਚਾਨਕ ਬਾਹਰ ਜਾਣ ਵਾਲਾ ਟ੍ਰੈਫਿਕ ਰੂਟਕਿਟ ਲੋਡਿੰਗ ਪੜਾਅ ਹੋ ਸਕਦਾ ਹੈ।
• ਅਸਪਸ਼ਟ ਜਾਂ ਉੱਚ-ਐਂਟਰੋਪੀ ਕੋਡ ਹਿੱਸਿਆਂ ਲਈ ਸਕੈਨਿੰਗ
ਅਜਿਹੇ ਟੂਲ ਵਰਤੋ ਜੋ ਸ਼ੱਕੀ ਕੋਡ ਐਂਟਰੋਪੀ ਜਾਂ ਗੈਰ-ASCII/ਪੜ੍ਹਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਭਾਗਾਂ ਨੂੰ ਫਲੈਗ ਕਰਦੇ ਹਨ pull requests. ਉਦਾਹਰਨ ਲਈ, ਲਈ ਇੱਕ ਸਕੈਨ ਏਕੀਕ੍ਰਿਤ ਕਰੋ ਬੇਸ 64 ਬਲੌਬ ਜਾਂ ਅਜੀਬ ਐਗਜ਼ੀਕਿਊਟਿਵ/ਈਵਲ ਵਰਤੋਂ। ਹਾਈਲਾਈਟ ਕੀਤਾ ਕੋਡ ਇੱਕ ਸਲੀਪਿੰਗ ਲੋਡਰ ਜਾਂ ਇੱਕ ਇਨਕ੍ਰਿਪਟਡ ਪੇਲੋਡ ਹੋ ਸਕਦਾ ਹੈ।
ਸਪਲਾਈ ਚੇਨ ਵਿੱਚ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਬਣਾਈ ਰੱਖਣਾ
ਲੰਬੇ ਸਮੇਂ ਲਈ, ਤੁਹਾਨੂੰ ਅਜਿਹੇ ਅਭਿਆਸਾਂ ਦੀ ਲੋੜ ਹੈ ਜੋ ਰੂਟਕਿਟ ਖੋਜ ਨੂੰ ਦੂਜੀ ਪ੍ਰਕਿਰਤੀ ਬਣਾਉਂਦੇ ਹਨ:
- ਨਿਰਭਰਤਾ ਪਿੰਨਿੰਗ ਅਤੇ ਲਾਕਫਾਈਲਾਂ: ਹਮੇਸ਼ਾ commit ਲਾਕਫਾਈਲਾਂ (ਪੈਕੇਜ-ਲਾਕ.ਜੇਸਨ, ਜ਼ਰੂਰਤਾਂ.ਲਾਕਆਦਿ). ਵਰਜਨਾਂ ਨੂੰ ਪਿੰਨ ਕਰੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਗਲਤੀ ਨਾਲ ਪਰਿਵਰਤਨਸ਼ੀਲ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਨਾ ਖਿੱਚੋ ਅਤੇ ਰੂਟਕਿੱਟ ਦੇ ਅੰਦਰ ਜਾਣ ਦਾ ਜੋਖਮ ਨਾ ਲਓ।
- ਰੀਲੀਜ਼ਾਂ ਅਤੇ ਪੈਕੇਜਾਂ ਦੇ ਕ੍ਰਿਪਟੋਗ੍ਰਾਫਿਕ ਦਸਤਖਤ: GPG ਜਾਂ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਨਾਲ ਆਪਣੇ ਖੁਦ ਦੇ ਬਿਲਡ ਆਰਟੀਫੈਕਟਸ 'ਤੇ ਦਸਤਖਤ ਕਰੋ। ਖਪਤਕਾਰ ਦਸਤਖਤਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹਨ; ਜੇਕਰ ਕੋਈ ਰੂਟਕਿਟ ਤੁਹਾਡੀ ਰਿਲੀਜ਼ ਨਾਲ ਛੇੜਛਾੜ ਕਰਦਾ ਹੈ, ਤਾਂ ਪੁਸ਼ਟੀਕਰਨ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਵਿਸ਼ਵਾਸ ਦੀ ਲੜੀ ਨੂੰ ਤੋੜ ਦਿੰਦਾ ਹੈ।
- ਦੀ ਨਿਯਮਤ ਸਮੀਖਿਆ ਤੀਜੀ ਧਿਰ ਅਤੇ ਪਰਿਵਰਤਨਸ਼ੀਲ ਬਦਲਾਅ: ਨਿਰਭਰਤਾ-ਨਿਗਰਾਨੀ ਵਾਲੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੋ ਨਵੀਂ ਜਾਂ ਬਦਲੀ ਹੋਈ ਨਿਰਭਰਤਾ ਨੂੰ ਫਲੈਗ ਕਰਦੇ ਹਨ। ਨਾਲ ਜੋੜੋ SBOM ਇੰਜੈਕਟ ਕੀਤੇ ਜਾਂ ਬਦਲੇ ਗਏ ਮੋਡੀਊਲ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਵੱਖਰਾ।
- ਨਿਰਭਰਤਾ ਵਹਾਅ ਲਈ ਨਿਰੰਤਰ ਨਿਗਰਾਨੀ ਜਾਂ ਅਣਅਧਿਕਾਰਤ ਤਬਦੀਲੀਆਂ: ਸਵੈਚਾਲਤ SBOM ਤੁਹਾਡੇ CI ਵਿੱਚ ਅੰਤਰ: ਜੇਕਰ ਅਣਕਿਆਸੀ ਨਿਰਭਰਤਾ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ ਤਾਂ ਬਿਲਡ ਅਸਫਲ ਹੋ ਜਾਂਦੇ ਹਨ। ਸਮੇਂ ਦੇ ਨਾਲ ਨਿਰਭਰਤਾ ਡ੍ਰਿਫਟ ਨੂੰ ਟਰੈਕ ਕਰੋ, ਅਤੇ ਜੇਕਰ ਕੁਝ ਉਮੀਦ ਕੀਤੀ ਸਥਿਤੀ ਤੋਂ ਭਟਕਦਾ ਹੈ ਤਾਂ ਚੇਤਾਵਨੀ ਦਿਓ: ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਰੂਟਕਿਟ commit ਜਾਂ ਨਿਰਭਰਤਾ ਨੂੰ ਬਦਲ ਦਿੱਤਾ।
ਸਿੱਟਾ
ਰੂਟਕਿਟਸ ਹੁਣ ਸਿਸਟਮ ਐਡਮਿਨ ਅਤੇ ਕਰਨਲ ਤੱਕ ਸੀਮਤ ਨਹੀਂ ਹਨ; ਉਹ ਵਿਕਾਸ ਦੇ ਦਿਲ ਵਿੱਚ ਪ੍ਰਵਾਸ ਕਰ ਗਏ ਹਨ: ਤੁਹਾਡੇ ਰਿਪੋਜ਼, ਬਿਲਡ, ਅਤੇ CI pipelines. ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਰੂਟਕਿਟ ਖੋਜ ਅਤੇ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਮੁੱਖ ਐਪਸੈਕ ਚਿੰਤਾਵਾਂ ਵਜੋਂ ਮੰਨਣਾ ਚਾਹੀਦਾ ਹੈ। ਹੈਸ਼ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, SBOM ਆਡਿਟਿੰਗ, ਦਸਤਖਤ ਕੀਤੇ commits, ਵਿਵਹਾਰ ਸੰਬੰਧੀ ਵਿਗਾੜਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ, ਅਤੇ ਨਿਰਭਰਤਾ ਸਫਾਈ, ਤੁਸੀਂ ਕੋਡ ਵਿੱਚ ਰਹਿਣ ਵਾਲੇ ਰੂਟਕਿੱਟਾਂ ਦੇ ਵਿਰੁੱਧ ਵਿਹਾਰਕ ਬਚਾਅ ਬਣਾਉਂਦੇ ਹੋ।
ਵਰਗਾ ਇੱਕ ਸੰਦ ਜ਼ਾਇਗੇਨੀ, ਸਾਫਟਵੇਅਰ ਸਪਲਾਈ-ਚੇਨ ਹਾਰਡਨਿੰਗ 'ਤੇ ਕੇਂਦ੍ਰਿਤ, DevSecOps ਟੀਮਾਂ ਨੂੰ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਬਣਾਈ ਰੱਖਣ ਅਤੇ ਵਰਕਫਲੋ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਰੂਟਕਿਟ ਖਤਰਿਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਸ਼ਕਤੀ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਡਿਵੈਲਪਰ-ਪਹਿਲੀ ਸੁਰੱਖਿਆ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸਹਿਯੋਗੀ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਰੈਪੋ, ਬਿਲਡ, ਜਾਂ ਉਤਪਾਦਨ ਵਿੱਚ ਫੈਲਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
