ਸੁਰੱਖਿਆ ਅਤੇ ਰਾਜ਼ ਪ੍ਰਬੰਧਨ: DevSecOps ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ

ਲਾਭ:

• DevSecOps ਅਤੇ ਭੇਦ ਪ੍ਰਬੰਧਨ ਦੇ ਸੁਨਹਿਰੀ ਨਿਯਮਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਸਮਰੱਥਾ (ਕੋਡ ਦਾਖਲ ਨਹੀਂ ਕਰਦਾ, ਵਾਲਟ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ, ਰਨ ਟਾਈਮ 'ਤੇ ਟੀਕਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ, ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਘੱਟੋ-ਘੱਟ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ)
• ਸੁਰੱਖਿਆ ਸਕੈਨ ਆਉਟਪੁੱਟ (SCA, SAST, ਚਿੱਤਰ, IaC, ਗੁਪਤ) ਅਤੇ ਰੱਖਿਆਤਮਕ ਉਦੇਸ਼ਾਂ ਲਈ ਆਡਿਟ ਕੋਡ ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਲਈ ਨਕਲੀ ਬੁੱਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਇਹ ਜਾਣਨਾ ਕਿ ਗੁਪਤ ਲੀਕ ਦਾ ਪਹਿਲਾ ਕਦਮ ਹੈ ਰੱਦ ਕਰਨਾ/ਉਲਟਣਾ ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਦੀ ਵਰਤੋਂ ਸਿਰਫ ਅਧਿਕਾਰਤ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ, ਰੱਖਿਆ ਉਦੇਸ਼ਾਂ ਲਈ, ਕਾਨੂੰਨੀ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ।

ਕਿਸੇ ਸਿਸਟਮ ਨੂੰ ਕਿੰਨੀ ਜਲਦੀ ਤੈਨਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਦਾ ਕੋਈ ਮਤਲਬ ਨਹੀਂ ਹੁੰਦਾ ਜਿਸ ਦਿਨ ਇਸ ਨਾਲ ਸਮਝੌਤਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਕਿ DevOps ਗਤੀ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ, ਸੁਰੱਖਿਆ ਨੂੰ ਕਈ ਵਾਰ ਅੰਤ ਤੱਕ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ - ਅਤੇ ਅੰਤ ਤੱਕ ਛੱਡੀ ਗਈ ਸੁਰੱਖਿਆ ਅਕਸਰ ਬਿਲਕੁਲ ਨਹੀਂ ਆਉਂਦੀ। DevSecOps ਉਹ ਪਹੁੰਚ ਹੈ ਜੋ DevOps ਦੇ ਪ੍ਰਵਾਹ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਅਤੇ ਹਰ ਪੜਾਅ 'ਤੇ ਸੁਰੱਖਿਆ ਨੂੰ ਰੱਖਦੀ ਹੈ: "ਸੁਰੱਖਿਆ ਨੂੰ ਖੱਬੇ ਪਾਸੇ ਬਦਲਣਾ" - ਯਾਨੀ, ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਇੱਕ ਕਮਜ਼ੋਰੀ ਨੂੰ ਫੜਨਾ, ਜਦੋਂ ਕੋਡ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਨਾ ਕਿ ਉਤਪਾਦ ਵਿੱਚ। DevSecOps ਪੇਸ਼ੇਵਰ ਲਈ, ਸੁਰੱਖਿਆ ਇੱਕ ਵੱਖਰੀ ਟੀਮ ਦਾ ਕੰਮ ਨਹੀਂ ਹੈ, ਪਰ ਹਰ ਪ੍ਰਤੀਬੱਧਤਾ, ਹਰ ਚਿੱਤਰ, ਹਰ ਮੈਨੀਫੈਸਟ ਦਾ ਹਿੱਸਾ ਹੈ।

ਇਸ ਯੂਨਿਟ ਵਿੱਚ ਦੋ ਮੁੱਖ ਧੁਰੇ ਹਨ। ਪਹਿਲਾ ਹੈ ਭੇਦ ਪ੍ਰਬੰਧਨ: ਗੁਪਤ ਜਾਣਕਾਰੀ ਜਿਵੇਂ ਕਿ ਪਾਸਵਰਡ, ਕੁੰਜੀਆਂ, ਸਰਟੀਫਿਕੇਟਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਬਣਾਉਣਾ, ਸਟੋਰੇਜ, ਵੰਡਣਾ ਅਤੇ ਘੁੰਮਾਉਣਾ। ਦੂਜਾ ਸੁਰੱਖਿਆ ਸਕੈਨਿੰਗ ਅਤੇ ਸਖ਼ਤ ਹੈ: ਨਿਰਭਰਤਾਵਾਂ, ਚਿੱਤਰਾਂ, ਸੰਰਚਨਾਵਾਂ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਨੂੰ ਲੱਭਣਾ। AI ਦੋਵਾਂ ਵਿੱਚ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਹਾਇਕ ਹੈ - ਇਹ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਖੁਲਾਸਾ ਕਰਦਾ ਹੈ, ਸਕੈਨ ਆਉਟਪੁੱਟ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ, ਫਿਕਸਾਂ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕਰਦਾ ਹੈ। ਪਰ ਸਭ ਤੋਂ ਨਾਜ਼ੁਕ ਚੇਤਾਵਨੀ ਇੱਥੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ: AI ਰੱਖਿਆ ਲਈ ਹੈ; ਕਿਸੇ ਹੋਰ ਦੇ ਸਿਸਟਮ ਤੱਕ ਅਣਅਧਿਕਾਰਤ ਪਹੁੰਚ, ਅਣਅਧਿਕਾਰਤ ਸਕੈਨਿੰਗ, ਜਾਂ ਹਮਲਾ ਕਰਨ ਵਾਲਾ ਟੂਲ ਬਣਾਉਣਾ ਗੈਰ-ਕਾਨੂੰਨੀ ਹੈ ਅਤੇ ਇਸ ਪਲੇਟਫਾਰਮ ਦੀ ਸਖਤ ਸੀਮਾ ਹੈ।

ਰਾਜ਼ ਪ੍ਰਬੰਧਨ ਦੇ ਸੁਨਹਿਰੀ ਨਿਯਮ

1. ਗੁਪਤ ਕਦੇ ਵੀ ਇਸਨੂੰ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਨਹੀਂ ਬਣਾਉਂਦਾ. ਡੌਕਰਫਾਈਲ ਨਹੀਂ, YAML ਨਹੀਂ, ਸਕ੍ਰਿਪਟ ਨਹੀਂ, ਗਿੱਟ ਨਹੀਂ। ਇੱਕ ਵਾਰ ਗਿਟ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਰਾਜ਼ ਅਤੀਤ ਵਿੱਚ ਕਾਇਮ ਰਹਿੰਦਾ ਹੈ.
2. ਭੇਦ ਕੇਂਦਰੀ ਵਾਲਟ ਵਿੱਚ ਰੱਖੇ ਜਾਂਦੇ ਹਨ। HashiCorp Vault, AWS ਸੀਕਰੇਟਸ ਮੈਨੇਜਰ, Azure Key Vault, GCP ਸੀਕਰੇਟ ਮੈਨੇਜਰ — ਇਹ ਸਟੋਰ ਭੇਦ ਐਨਕ੍ਰਿਪਟਡ, ਐਕਸੈਸ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ 'ਤੇ ਨਜ਼ਰ ਰੱਖਦੇ ਹਨ।
3. ਇਹ ਓਪਰੇਸ਼ਨ ਦੇ ਸਮੇਂ ਟੀਕਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ. ਐਪਲੀਕੇਸ਼ਨ ਚੱਲਦੇ ਸਮੇਂ ਵਾਲਟ ਜਾਂ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਤੋਂ ਰਾਜ਼ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਨਾ ਕਿ ਡਿਸਕ ਤੋਂ।
4. ਇਹ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਘੁੰਮਦਾ ਹੈ. ਜਿੰਨਾ ਚਿਰ ਗੁਪਤ ਰਹਿੰਦਾ ਹੈ, ਲੀਕ ਹੋਣ ਦਾ ਖ਼ਤਰਾ ਓਨਾ ਹੀ ਵੱਧ ਹੁੰਦਾ ਹੈ। ਆਟੋ-ਸਪਿਨ ਆਦਰਸ਼ ਹੈ।
5. ਘੱਟੋ-ਘੱਟ ਅਧਿਕਾਰ. ਸਿਰਫ਼ ਉਹੀ ਸੇਵਾ ਜਿਸਨੂੰ ਇਸਦੀ ਲੋੜ ਹੈ ਹਰ ਗੁਪਤ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੀ ਹੈ।

ਸੰਕੇਤ: ਇੱਕਲਾ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਜਵਾਬੀ ਉਪਾਅ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਇੱਕ ਗੁਪਤ ਸਕੈਨਰ (ਜਿਵੇਂ ਕਿ git-secrets, gitleaks, trufflehog) ਲਗਾਉਣਾ ਹੈ: ਇਹ ਵਚਨਬੱਧਤਾ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੇਕਰ ਗਲਤੀ ਨਾਲ ਕੋਈ ਗੁਪਤ ਕੰਮ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਸਰੋਤ 'ਤੇ ਲੀਕ ਨੂੰ ਰੋਕਦਾ ਹੈ. AI ਇਹਨਾਂ ਬ੍ਰਾਊਜ਼ਰਾਂ ਦੇ ਪਾਈਪਲਾਈਨ ਏਕੀਕਰਣ ਨੂੰ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਕਦਮ ਦਰ ਕਦਮ: ਇੱਕ ਗੁਪਤ ਲੀਕ ਦਾ ਜਵਾਬ ਦੇਣਾ

ਜੇ ਕੋਈ ਰਾਜ਼ ਲੀਕ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਘਬਰਾਓ ਨਾ, ਆਦੇਸ਼ ਮਹੱਤਵਪੂਰਨ ਹੈ:

1. ਰੱਦ ਕਰੋ ਅਤੇ ਤੁਰੰਤ ਘੁੰਮਾਓ। ਲੀਕ ਹੋਈ ਕੁੰਜੀ ਨੂੰ ਅਵੈਧ ਕਰੋ, ਨਵੀਂ ਬਣਾਓ। ਸਿਰਫ਼ ਇਸਨੂੰ ਮਿਟਾਉਣਾ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ - ਇਹ ਅਤੀਤ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ।
2. ਪ੍ਰਭਾਵ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ। ਇਹ ਕੁੰਜੀ ਕਿੱਥੇ ਪਹੁੰਚੀ? ਕੀ ਇਹ ਦੁਰਵਿਵਹਾਰ ਕੀਤਾ ਗਿਆ ਹੈ? ਲਾਗਾਂ ਦੀ ਜਾਂਚ ਕਰੋ।
3. ਸਰੋਤ ਬੰਦ ਕਰੋ। ਇਹ ਕਿਵੇਂ ਲੀਕ ਹੋਇਆ? ਸਾਫ਼ ਕੋਡ, ਇਤਿਹਾਸ; ਪਰ ਯਾਦ ਰੱਖੋ: ਰੱਦ ਕਰਨਾ ਕਲੀਅਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ।
4. ਰੋਕੋ। ਗੁਪਤ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਇਹ ਦੁਹਰਾਇਆ ਨਾ ਜਾਵੇ।

ਧਿਆਨ ਦਿਓ: ਸਭ ਤੋਂ ਮਹਿੰਗੀ ਬਾਜ਼ੀ ਸਿਰਫ ਲੀਕ ਹੋਏ ਰਾਜ਼ ਨੂੰ ਵਾਪਸ ਨਾ ਕਰਨਾ ਹੈ ਕਿਉਂਕਿ "ਕਿਸੇ ਨੇ ਇਸਨੂੰ ਨਹੀਂ ਦੇਖਿਆ"। ਪਬਲਿਕ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਛੱਡੀ ਗਈ ਇੱਕ ਕੁੰਜੀ ਨੂੰ ਬੋਟਾਂ ਦੁਆਰਾ ਸਕਿੰਟਾਂ ਵਿੱਚ ਸਕੈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਸ਼ੱਕ ਹੋਵੇ, ਘੁੰਮਾਓ - ਰੋਟੇਸ਼ਨ ਦੀ ਲਾਗਤ ਘੱਟ ਹੈ, ਲੀਕੇਜ ਦੀ ਲਾਗਤ ਘਾਤਕ ਹੈ।

ਸੁਰੱਖਿਆ ਸਕੈਨ ਦੀਆਂ ਕਿਸਮਾਂ

DevSecOps ਸਕੈਨਿੰਗ ਦੀਆਂ ਕਈ ਪਰਤਾਂ ਵਰਤਦਾ ਹੈ; AI ਹਰੇਕ ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਵਿੱਚ ਮਦਦਗਾਰ ਹੈ:

• SCA (ਸਾਫਟਵੇਅਰ ਕੰਪੋਜੀਸ਼ਨ ਵਿਸ਼ਲੇਸ਼ਣ): ਤੁਹਾਡੇ ਦੁਆਰਾ ਵਰਤੇ ਜਾਂਦੇ ਓਪਨ ਸੋਰਸ ਨਿਰਭਰਤਾਵਾਂ ਵਿੱਚ ਜਾਣੀਆਂ ਗਈਆਂ ਕਮਜ਼ੋਰੀਆਂ (CVE) ਲੱਭਦਾ ਹੈ।
• SAST (ਸਟੈਟਿਕ ਐਪਲੀਕੇਸ਼ਨ ਸੁਰੱਖਿਆ ਟੈਸਟਿੰਗ): ਇਸ ਨੂੰ ਚਲਾਏ ਬਿਨਾਂ ਕਮਜ਼ੋਰੀਆਂ ਲਈ ਸਰੋਤ ਕੋਡ ਨੂੰ ਸਕੈਨ ਕਰਦਾ ਹੈ।
• DAST (ਡਾਇਨੈਮਿਕ ਐਪਲੀਕੇਸ਼ਨ ਸਕਿਓਰਿਟੀ ਟੈਸਟਿੰਗ): ਚੱਲ ਰਹੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਬਾਹਰੀ ਤੌਰ 'ਤੇ ਜਾਂਚ ਕਰਦਾ ਹੈ।
• ਚਿੱਤਰ ਸਕੈਨਿੰਗ: ਕੰਟੇਨਰ ਚਿੱਤਰ (ਟ੍ਰੀਵੀ, ਡੌਕਰ ਸਕਾਊਟ) ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਲੱਭਦਾ ਹੈ।
• IaC ਸਕੈਨਿੰਗ: Terraform/manifests (tfsec, checkov) ਵਿੱਚ ਗਲਤ ਸੰਰਚਨਾ ਲੱਭਦਾ ਹੈ।

ਸਾਵਧਾਨ: ਇੱਕ ਸਕੈਨਰ ਸੈਂਕੜੇ ਖੋਜਾਂ ਨੂੰ ਡੰਪ ਕਰਦਾ ਹੈ; ਇਨ੍ਹਾਂ ਸਾਰਿਆਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਠੀਕ ਕਰਨਾ ਅਸੰਭਵ ਹੈ। ਖੋਜਾਂ ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਲਈ AI ਦੀ ਵਰਤੋਂ ਕਰੋ: ਜੋ ਅਸਲ ਵਿੱਚ ਸ਼ੋਸ਼ਣਯੋਗ ਹਨ, ਜੋ ਸਿਧਾਂਤ ਵਿੱਚ ਸਪੱਸ਼ਟ ਹਨ ਪਰ ਅਭਿਆਸ ਵਿੱਚ ਪਹੁੰਚਯੋਗ ਨਹੀਂ ਹਨ? ਪਰ ਆਪਣੇ ਖੁਦ ਦੇ ਸੰਦਰਭ ਨਾਲ ਅੰਤਿਮ ਤਰਜੀਹ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ.

ਰਾਸਟਰ ਲੇਅਰਾਂ ਦੀ ਸਾਰਣੀ

ਪਰਤ

ਇਹ ਕੀ ਸਕੈਨ ਕਰਦਾ ਹੈ?

ਨਮੂਨਾ ਵਾਹਨ

ਜਦੋਂ

ਐਸ.ਸੀ.ਏ

ਨਿਰਭਰਤਾ ਕਮਜ਼ੋਰੀਆਂ (CVE)

ਡਿਪੈਂਡਬੋਟ, ਸਨਾਈਕ

ਹਰ ਬਿਲਡ

SAST

ਸਰੋਤ ਕੋਡ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ

Semgrep, CodeQL

ਹਰ ਪੀ.ਆਰ

ਚਿੱਤਰ ਸਕੈਨਿੰਗ

ਕੰਟੇਨਰ ਕਮਜ਼ੋਰੀਆਂ

ਤ੍ਰਿਵੀ, ਸਕਾਊਟ

ਬਣਾਉਣ ਦੇ ਬਾਅਦ

IaC ਸਕੈਨ

ਗਲਤ ਸੰਰਚਨਾ

tfsec, checkov

ਟੈਰਾਫਾਰਮ ਪੀ.ਆਰ

ਗੁਪਤ ਸਕੈਨ

ਲੀਕ ਹੋਏ ਭੇਦ

gitleaks

ਹਰ ਵਚਨਬੱਧਤਾ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

ਕੇਸ 1 - 300 CVE, 12 ਅਸਲ ਜੋਖਮ। ਇੱਕ ਚਿੱਤਰ ਸਕੈਨ ਨੇ 300 ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਰਿਪੋਰਟ ਕੀਤੀ; ਟੀਮ ਨੂੰ ਅਧਰੰਗ ਹੋ ਗਿਆ। AI ਨੂੰ ਸਕੈਨ ਆਉਟਪੁੱਟ ਦਿਓ ਅਤੇ ਪੁੱਛੋ ਕਿ "ਕਿਨ੍ਹਾਂ ਦਾ ਰਿਮੋਟ ਤੋਂ ਸ਼ੋਸ਼ਣ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਕੀ ਉਹ ਪਹੁੰਚਯੋਗ ਹਨ?" ਉਨ੍ਹਾਂ ਨੇ ਇਸ ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ। AI ਨੇ 12 ਅਸਲ ਜੋਖਮ ਭਰਪੂਰ ਖੋਜਾਂ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ। ਟੀਮ ਨੇ ਪਹਿਲਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਬੰਦ ਕੀਤਾ; ਬਾਕੀਆਂ ਨੂੰ ਉਸ ਨੇ ਯੋਜਨਾਬੱਧ ਆਧਾਰ 'ਤੇ ਨੌਕਰੀ 'ਤੇ ਰੱਖਿਆ। ਘਬਰਾਹਟ ਨੂੰ ਤਰਜੀਹ ਦਿਓ.

ਕੇਸ 2 - ਰੋਟੇਸ਼ਨ ਨੇ ਇੱਕ ਹਮਲੇ ਨੂੰ ਨਾਕਾਮ ਕਰ ਦਿੱਤਾ। ਇੱਕ ਡਿਵੈਲਪਰ ਨੇ ਗਲਤੀ ਨਾਲ ਇੱਕ ਜਨਤਕ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਇੱਕ ਕਲਾਉਡ ਕੁੰਜੀ ਨੂੰ ਧੱਕ ਦਿੱਤਾ। ਅਲਾਰਮ ਬੰਦ ਹੋ ਗਿਆ; ਟੀਮ ਨੇ 4 ਮਿੰਟਾਂ ਵਿੱਚ ਕੈਂਸਲ ਕਰਕੇ ਚਾਬੀ ਵਾਪਸ ਕਰ ਦਿੱਤੀ। ਲੌਗਸ ਨੇ ਦਿਖਾਇਆ ਕਿ ਕੁੰਜੀ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਬੋਟ ਤੋਂ ਪੁੱਛੀ ਗਈ ਸੀ - ਪਰ ਇਹ ਹੁਣ ਅਵੈਧ ਸੀ। ਤੇਜ਼ ਤਬਦੀਲੀ ਨੇ ਇੱਕ ਸੰਭਾਵੀ ਬਿਲਿੰਗ ਆਫ਼ਤ ਅਤੇ ਡੇਟਾ ਲੀਕ ਨੂੰ ਰੋਕਿਆ।

ਕੇਸ 3 - IaC ਸਕੈਨ ਨੇ ਇੱਕ ਖੁੱਲੀ ਬਾਲਟੀ ਫੜੀ। ਇੱਕ AI-ਸਹਾਇਤਾ ਪ੍ਰਾਪਤ IaC ਸਕੈਨ ਨੇ ਟੈਰਾਫਾਰਮ ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਟੋਰੇਜ ਬਾਲਟੀ ਫੜੀ ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਡ 'ਤੇ ਜਾਣ ਤੋਂ ਬਿਨਾਂ "ਪਬਲਿਕ ਰੀਡ" ਦੀ ਇਜਾਜ਼ਤ ਸੀ। ਡਿਵੈਲਪਰ ਨੇ ਇਸਨੂੰ "ਟੈਸਟਿੰਗ ਲਈ" ਖੋਲ੍ਹਿਆ ਸੀ ਅਤੇ ਇਸਨੂੰ ਬੰਦ ਕਰਨਾ ਭੁੱਲ ਗਿਆ ਸੀ। ਪਾਈਪਲਾਈਨ ਨੇ ਵਚਨਬੱਧਤਾ ਨੂੰ ਰੋਕਿਆ; ਓਪਨ ਨੇ ਇਸਨੂੰ ਕਦੇ ਵੀ ਉਤਪਾਦਨ ਵਿੱਚ ਨਹੀਂ ਬਣਾਇਆ। ਇਹ ਬਿਲਕੁਲ ਖੱਬੇ ਪਾਸੇ ਸਵਾਈਪ ਕਰਨ ਦਾ ਬਿੰਦੂ ਹੈ।

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ

1) ਸਕੈਨ ਆਉਟਪੁੱਟ ਨੂੰ ਤਰਜੀਹ ਦਿਓ:

ਹੇਠਾਂ ਸੁਰੱਖਿਆ ਸਕੈਨ ਆਉਟਪੁੱਟ ਨੂੰ ਤਰਜੀਹ ਦਿਓ। ਹਰੇਕ ਖੋਜ ਲਈ: (1) ਕੀ ਇਹ ਸੱਚਮੁੱਚ ਸ਼ੋਸ਼ਣਯੋਗ ਹੈ (ਰਿਮੋਟ/ਅਪ੍ਰਮਾਣਿਤ?), (2) ਕੀ ਇਹ ਸਾਡੇ ਸੰਦਰਭ ਵਿੱਚ ਪਹੁੰਚਯੋਗ ਹੈ, (3) ਉਪਚਾਰ ਦੀ ਕੋਸ਼ਿਸ਼, (4) ਸਿਫਾਰਸ਼ ਕੀਤੀ ਤਰਜੀਹ (ਨਾਜ਼ੁਕ/ਉੱਚ/ਮੱਧਮ/ਨੀਚ)। ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ 5 ਨੂੰ ਉਜਾਗਰ ਕਰੋ। ਸਪਸ਼ਟ ਬੋਲੋ; ਦਰਸਾਉ ਕਿ ਮੈਨੂੰ ਮੇਰੇ ਸੰਦਰਭ ਨਾਲ ਹਰੇਕ ਤਰਜੀਹ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਆਉਟਪੁੱਟ: [SCAN]

2) ਗੁਪਤ ਪ੍ਰਬੰਧਨ ਡਿਜ਼ਾਈਨ:

[APPLICATION/INFRstructure] ਲਈ ਇੱਕ ਭੇਦ ਪ੍ਰਬੰਧਨ ਪਹੁੰਚ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰੋ: ਕਿਹੜਾ ਵਾਲਟ, ਰਨਟਾਈਮ 'ਤੇ ਰਾਜ਼ ਨੂੰ ਕਿਵੇਂ ਇੰਜੈਕਟ ਕਰਨਾ ਹੈ, ਰੋਟੇਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਸਵੈਚਲਿਤ ਕਰਨਾ ਹੈ, ਘੱਟੋ-ਘੱਟ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ? ਇੱਕ ਠੋਸ ਪ੍ਰਵਾਹ ਦਾ ਵਰਣਨ ਕਰੋ ਜੋ ਕਦੇ ਵੀ ਕੋਡ ਵਿੱਚ ਗੁਪਤ ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰਦਾ ਹੈ।

3) ਕੋਡ (ਰੱਖਿਆ) ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਖੋਜ ਕਰਨਾ:

ਸੁਰੱਖਿਆ ਲਈ ਹੇਠਾਂ ਮੇਰੇ ਖੁਦ ਦੇ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ (ਮੇਰੇ ਕੋਲ ਇਜਾਜ਼ਤ ਹੈ): ਕੀ ਇੱਥੇ ਕੋਈ ਟੀਕਾ, ਏਮਬੈਡਡ ਸੀਕ੍ਰੇਟ, ਅਸੁਰੱਖਿਅਤ ਡਿਫੌਲਟ, ਗੈਰ-ਪ੍ਰਮਾਣਿਤ ਇਨਪੁਟ ਹੈ? ਹਰ ਇੱਕ ਨੂੰ ਇਸਦਾ ਮਹੱਤਵ ਅਤੇ ਸੁਧਾਰ ਦਿਉ। ਉਦੇਸ਼ ਰੱਖਿਆ ਅਤੇ ਇਕਸੁਰਤਾ ਹੈ. ਕੋਡ: [CODE]

4) ਗੁਪਤ ਲੀਕ ਜਵਾਬ ਯੋਜਨਾ:

ਇੱਕ [ਗੁਪਤ ਕਿਸਮ] ਨੇ ਗਲਤੀ ਨਾਲ [LOCATION] ਵਿੱਚ ਘੁਸਪੈਠ ਕੀਤੀ ਹੋ ਸਕਦੀ ਹੈ। ਮੈਨੂੰ ਕਦਮ ਦਰ ਕਦਮ ਦਖਲਅੰਦਾਜ਼ੀ ਆਰਡਰ ਦਿਓ: ਮੈਨੂੰ ਪਹਿਲਾਂ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਰੱਦ ਕਰਨਾ/ਵਾਪਸੀ), ਪ੍ਰਭਾਵ ਦਾ ਮੁਲਾਂਕਣ ਕਿਵੇਂ ਕਰਨਾ ਹੈ, ਆਵਰਤੀ ਨੂੰ ਕਿਵੇਂ ਰੋਕਿਆ ਜਾਵੇ? ਇਹ ਵੀ ਦੱਸੋ ਕਿ ਸਿਰਫ਼ ਮਿਟਾਉਣਾ ਹੀ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਮੈਂ ਇਸ ਸਿਸਟਮ ਨੂੰ ਕਿਵੇਂ ਹੈਕ ਕਰਾਂ/ਇਸ ਕਮਜ਼ੋਰੀ ਦਾ ਸ਼ੋਸ਼ਣ ਕਿਵੇਂ ਕਰਾਂ?"

ਇਹ ਬੇਨਤੀ ਅਨੈਤਿਕ ਅਤੇ ਸਖਤੀ ਨਾਲ ਇਸ ਪਲੇਟਫਾਰਮ ਦੀਆਂ ਸੀਮਾਵਾਂ ਤੋਂ ਬਾਹਰ ਹੈ। ਹਮਲੇ ਲਈ AI ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਗੈਰ-ਕਾਨੂੰਨੀ ਹੈ।

ਮਜਬੂਤ: "ਸੁਰੱਖਿਆ ਲਈ ਮੇਰੀ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਕੋਡ ਨੂੰ ਅਧਿਕਾਰਤ ਕਰੋ: ਏਮਬੈਡਡ ਭੇਦ, ਇੰਜੈਕਸ਼ਨ ਜੋਖਮ ਅਤੇ ਅਸੁਰੱਖਿਅਤ ਡਿਫੌਲਟ ਲੱਭੋ, ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਠੀਕ ਕਰੋ। ਟੀਚਾ ਸਿਸਟਮ ਨੂੰ ਸਖ਼ਤ ਕਰਨਾ ਹੈ।"

ਅੰਤਰ: ਦੂਜੀ ਬੇਨਤੀ ਰੱਖਿਆਤਮਕ ਉਦੇਸ਼ਾਂ ਲਈ, ਅਧਿਕਾਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ ਅਤੇ ਇਕਸੁਰਤਾ ਲਈ ਹੈ। ਇਹ DevSecOps ਵਿੱਚ AI ਦੀ ਸਹੀ ਵਰਤੋਂ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• ਕੋਡ/ਇਤਿਹਾਸ ਵਿੱਚ ਰਾਜ਼ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ। ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਲਗਾਤਾਰ ਕਮਜ਼ੋਰੀ।
• ਲੀਕ ਹੋਏ ਰਾਜ਼ ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕਰ ਰਿਹਾ। "ਕਿਸੇ ਨੇ ਇਸਨੂੰ ਨਹੀਂ ਦੇਖਿਆ" ਸਭ ਤੋਂ ਮਹਿੰਗੀ ਬਾਜ਼ੀ ਹੈ।
• ਸਾਰੀਆਂ ਸਕ੍ਰੀਨਿੰਗ ਖੋਜਾਂ ਨੂੰ ਬਰਾਬਰ ਦੇ ਤੌਰ 'ਤੇ ਦੇਖਣਾ। ਪ੍ਰਾਥਮਿਕਤਾ ਦੁਆਰਾ ਅਧਰੰਗ ਹੋ ਜਾਣਾ ਜਾਂ ਅਸਲ ਜੋਖਮ ਗੁੰਮ ਹੋਣਾ।
• ਸੁਰੱਖਿਆ ਨੂੰ ਅੰਤ ਤੱਕ ਛੱਡਣਾ। ਉਤਪਾਦ ਵਿਚਲਾ ਪਾੜਾ ਪਾਈਪਲਾਈਨ ਵਿਚਲੇ ਪਾੜੇ ਨਾਲੋਂ ਕਈ ਗੁਣਾ ਮਹਿੰਗਾ ਹੈ।
• ਨਿਊਨਤਮ ਅਧਿਕਾਰ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨਾ। ਇੱਕ ਗੁਪਤ/ਭੂਮਿਕਾ ਜਿਸਦੀ ਹਰ ਚੀਜ਼ ਤੱਕ ਪਹੁੰਚ ਹੁੰਦੀ ਹੈ, ਇੱਕ ਇੱਕਲੇ ਲੀਕ ਨੂੰ ਇੱਕ ਤਬਾਹੀ ਬਣਾਉਂਦੀ ਹੈ।
• ਹਮਲੇ ਲਈ AI ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ। ਗੈਰ-ਕਾਨੂੰਨੀ ਅਤੇ ਆਫ-ਪਲੇਟਫਾਰਮ।

ਸਾਰੰਸ਼ ਵਿੱਚ

DevSecOps ਸ਼ੁਰੂ ਵਿੱਚ ਅਤੇ DevOps ਪ੍ਰਵਾਹ ਦੇ ਹਰ ਪੜਾਅ 'ਤੇ ਸੁਰੱਖਿਆ ਰੱਖਦਾ ਹੈ — ਕੋਡ ਅਤੇ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਨੂੰ ਫੜਨਾ, ਉਤਪਾਦ ਵਿੱਚ ਨਹੀਂ। ਰਾਜ਼ ਪ੍ਰਬੰਧਨ ਦੇ ਸੁਨਹਿਰੀ ਨਿਯਮ: ਗੁਪਤ ਕੋਡ ਵਿੱਚ ਦਾਖਲ ਨਹੀਂ ਹੁੰਦਾ, ਕੇਂਦਰੀ ਵਾਲਟ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ, ਰਨਟਾਈਮ 'ਤੇ ਟੀਕਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ, ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਘੱਟੋ-ਘੱਟ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਨਾਲ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਲੀਕ ਵਿੱਚ ਪਹਿਲਾ ਕਦਮ ਹਮੇਸ਼ਾ ਅਧੂਰਾ/ਵਾਪਸੀ ਹੁੰਦਾ ਹੈ। AI ਸਕੈਨ ਆਉਟਪੁੱਟ ਨੂੰ ਤਰਜੀਹ ਦੇਣ, ਗੁਪਤ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ, ਅਤੇ ਰੱਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਕੋਡ ਦਾ ਨਿਰੀਖਣ ਕਰਨ ਵਿੱਚ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ - ਪਰ ਇਹ ਸਿਰਫ ਰੱਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਅਤੇ ਉਹਨਾਂ ਸਿਸਟਮਾਂ 'ਤੇ ਕਾਨੂੰਨੀ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ 'ਤੇ ਤੁਹਾਡੇ ਕੋਲ ਅਧਿਕਾਰ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਆਪਣਾ ਖੁਦ ਦਾ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਲਓ (ਜਿਸ ਲਈ ਤੁਹਾਡੇ ਕੋਲ ਅਧਿਕਾਰ ਹੈ)। (1) ਏਮਬੇਡ ਕੀਤੇ ਗੁਪਤ ਅਤੇ ਅਸੁਰੱਖਿਅਤ ਡਿਫਾਲਟਸ ਨੂੰ "ਕੋਡ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਭਾਲ" ਟੈਮਪਲੇਟ ਨਾਲ ਚੈੱਕ ਕਰੋ। (2) ਸੁਰੱਖਿਆ ਸਕੈਨ ਆਉਟਪੁੱਟ (ਅਸਲ ਜਾਂ ਨਮੂਨਾ) ਨੂੰ "ਟ੍ਰਾਈਏਜ" ਟੈਂਪਲੇਟ ਰਾਹੀਂ ਕ੍ਰਮਬੱਧ ਕਰੋ ਅਤੇ 3 ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ ਖੋਜਾਂ ਦੀ ਪਛਾਣ ਕਰੋ। (3) "ਗੁਪਤ ਪ੍ਰਬੰਧਨ ਡਿਜ਼ਾਈਨ" ਟੈਂਪਲੇਟ ਨਾਲ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਇੱਕ ਪ੍ਰਵਾਹ ਡਰਾਫਟ ਤਿਆਰ ਕਰੋ ਜੋ ਕੋਡ ਤੋਂ ਗੁਪਤ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹਟਾ ਦਿੰਦਾ ਹੈ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਤਸਦੀਕ ਕੀਤਾ ਹੈ ਕਿ ਮੇਰੇ ਕੋਡ, ਚਿੱਤਰ ਅਤੇ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਕੋਈ ਏਮਬੈਡਡ ਰਾਜ਼ ਨਹੀਂ ਹਨ।
• [ ] ਮੈਂ ਭੇਦ ਇੱਕ ਕੇਂਦਰੀ ਵਾਲਟ ਵਿੱਚ ਰੱਖਦਾ ਹਾਂ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਰਨਟਾਈਮ ਵਿੱਚ ਇੰਜੈਕਟ ਕਰਦਾ ਹਾਂ।
• [ ] ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਲੀਕ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਪਹਿਲਾ ਕਦਮ ਅਧੂਰਾ/ਵਾਪਸੀ ਹੈ।
• [ ] ਮੈਂ ਸ਼ੋਸ਼ਣ ਅਤੇ ਮੇਰੇ ਸੰਦਰਭ ਦੇ ਆਧਾਰ 'ਤੇ ਸਕੈਨ ਖੋਜਾਂ ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ।
• [ ] ਮੈਂ ਸੁਰੱਖਿਆ ਸਕੈਨਾਂ ਨੂੰ ਪਾਈਪਲਾਈਨ (ਖੱਬੇ ਪਾਸੇ) ਦੇ ਸ਼ੁਰੂਆਤੀ ਪੜਾਵਾਂ 'ਤੇ ਲੈ ਗਿਆ।
• [ ] ਮੈਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਸਿਸਟਮਾਂ 'ਤੇ ਰੱਖਿਆਤਮਕ ਉਦੇਸ਼ਾਂ ਲਈ AI ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਜਿਸ ਵਿੱਚ ਮੇਰੇ ਕੋਲ ਅਧਿਕਾਰ ਹੈ।