ਕੋਡ ਪੁਸ਼ਟੀਕਰਨ, ਕਮਜ਼ੋਰੀਆਂ, ਅਤੇ AI ਆਉਟਪੁੱਟ ਦੇ ਜੋਖਮ

ਲਾਭ:

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

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

ਇੱਥੇ ਅਸੀਂ ਤਿੰਨ ਪਰਤਾਂ 'ਤੇ "ਪ੍ਰਮਾਣਿਕਤਾ" 'ਤੇ ਵਿਚਾਰ ਕਰਦੇ ਹਾਂ: ਸ਼ੁੱਧਤਾ (ਕੀ ਕੋਡ ਅਸਲ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ?), ਸੁਰੱਖਿਆ (ਕੀ ਇਹ ਖਤਰਨਾਕ ਇਨਪੁਟ ਦਾ ਸਾਮ੍ਹਣਾ ਕਰਦਾ ਹੈ?), ਅਤੇ ਪ੍ਰੋਵੇਨੈਂਸ/ਲਾਇਸੈਂਸ (ਕੀ ਮੇਰੇ ਕੋਲ ਇਸ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਅਧਿਕਾਰ ਹੈ?)। ਹਰ ਪਰਤ ਦੇ ਨਿਯੰਤਰਣ ਦੇ ਆਪਣੇ ਸਾਧਨ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਨੂੰ ਵੀ "ਏਆਈ ਨੇ ਇਹੀ ਕਿਹਾ ਹੈ" ਨਾਲ ਬਾਈਪਾਸ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਜੋਖਮ ਦੀਆਂ ਤਿੰਨ ਪਰਤਾਂ

1. ਸ਼ੁੱਧਤਾ ਦਾ ਜੋਖਮ (ਭਰਮ)। ਮਾਡਲ ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ, ਇੱਕ API ਦੀ ਦੁਰਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ, ਚੁੱਪਚਾਪ ਇੱਕ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਸਕਦਾ ਹੈ। ਕੋਡ "ਵਾਜਬ" ਜਾਪਦਾ ਹੈ ਪਰ ਗਲਤ ਹੈ। ਐਂਟੀਡੋਟ: ਸੰਕਲਨ, ਟੈਸਟਿੰਗ, ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਵਿਜ਼ੂਅਲ ਨਿਰੀਖਣ।

2. ਸੁਰੱਖਿਆ ਖਤਰਾ। AI ਸਿਖਲਾਈ ਡੇਟਾ ਵਿੱਚ ਅਸੁਰੱਖਿਅਤ ਪੈਟਰਨਾਂ ਨੂੰ ਦੁਹਰਾ ਸਕਦਾ ਹੈ: SQL ਇੰਜੈਕਸ਼ਨ, ਅਣਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ, ਕਮਜ਼ੋਰ ਐਨਕ੍ਰਿਪਸ਼ਨ, ਅਸੁਰੱਖਿਅਤ ਡੀਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ, ਓਪਨ ਰੀਡਾਇਰੈਕਸ਼ਨ ਲਈ ਕਮਜ਼ੋਰ ਪੁੱਛਗਿੱਛ। ਕੋਡ ਕੰਮ ਕਰਦਾ ਹੈ ਪਰ ਹਮਲੇ ਲਈ ਕਮਜ਼ੋਰ ਹੈ। ਐਂਟੀਡੋਟ: ਸੁਰੱਖਿਆ-ਕੇਂਦ੍ਰਿਤ ਸਮੀਖਿਆ, ਸਵੈਚਲਿਤ ਸਕੈਨਰ (SAST), ਅਤੇ ਜਾਣੇ-ਪਛਾਣੇ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ।

3. ਸਰੋਤ/ਲਾਇਸੈਂਸ ਜੋਖਮ। AI ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਕਾਪੀਰਾਈਟ ਜਾਂ ਪ੍ਰਤਿਬੰਧਿਤ ਲਾਇਸੰਸਸ਼ੁਦਾ ਕੋਡ ਨਾਲ ਮਿਲਦਾ ਜੁਲਦਾ ਹੈ, ਜਾਂ ਇਹ ਇੱਕ ਅਣਉਚਿਤ ਲਾਇਸੰਸਸ਼ੁਦਾ ਨਿਰਭਰਤਾ ਦਾ ਸੁਝਾਅ ਦੇ ਸਕਦਾ ਹੈ। ਐਂਟੀਡੋਟ: ਨਿਰਭਰਤਾ ਅਤੇ ਲਾਇਸੈਂਸ ਜਾਂਚ, ਮੌਲਿਕਤਾ ਦੀ ਜਾਂਚ, ਕਾਰਪੋਰੇਟ ਨੀਤੀ।

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

ਕਦਮ ਦਰ ਕਦਮ: ਲੇਅਰਡ ਪ੍ਰਮਾਣੀਕਰਨ ਗੇਟ

1. ਸਮਝ ਨਾਲ ਪੜ੍ਹੋ। ਇਸ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੋਡ ਨੂੰ ਅਸਲ ਵਿੱਚ ਸਮਝੋ; ਕੋਡ ਨੂੰ ਮਿਲਾਓ ਨਾ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਸਮਝਦੇ. ਜੇਕਰ ਤੁਸੀਂ "ਇਹ ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ" ਦੀ ਵਿਆਖਿਆ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਤਾਂ ਇਹ ਅਜੇ ਪ੍ਰਮਾਣਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ।
2. ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਇਹ ਮੌਜੂਦ ਹੈ। ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਵਰਤਿਆ ਗਿਆ ਹਰ ਫੰਕਸ਼ਨ, API ਅਤੇ ਪੈਕੇਜ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹੈ ਅਤੇ ਸਹੀ ਢੰਗ ਨਾਲ ਵਰਤਿਆ ਗਿਆ ਹੈ (ਭਰਮ ਗੇਟ)।
3. ਆਟੋਮੇਟਿਡ ਟੂਲ ਚਲਾਓ। ਕੰਪਾਈਲਰ, ਲਿੰਟਰ (ਸਟਾਈਲ/ਐਰਰ ਸਕੈਨਰ), ਟਾਈਪ ਚੈਕਰ, ਯੂਨਿਟ ਟੈਸਟ, ਅਤੇ ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਇੱਕ SAST (ਸਟੈਟਿਕ ਐਪਲੀਕੇਸ਼ਨ ਸਕਿਓਰਿਟੀ ਟੈਸਟਿੰਗ — ਟੂਲ ਜੋ ਕਮਜ਼ੋਰੀਆਂ ਲਈ ਸਰੋਤ ਕੋਡ ਨੂੰ ਸਕੈਨ ਕਰਦਾ ਹੈ)।
4. ਇਸ ਨੂੰ ਸੁਰੱਖਿਆ ਦੇ ਨਜ਼ਰੀਏ ਤੋਂ ਦੇਖੋ। ਕੀ ਇਨਪੁਟ ਪ੍ਰਮਾਣਿਤ ਹੈ? ਕੀ ਪੁੱਛਗਿੱਛ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਹੈ? ਕੀ ਰਾਜ਼ ਦਫ਼ਨ ਹੋ ਗਿਆ ਹੈ? ਕੀ ਅਧਿਕਾਰ ਨਿਯੰਤਰਣ ਹੈ?
5. ਸਰੋਤ ਅਤੇ ਲਾਇਸੈਂਸ ਦੀ ਜਾਂਚ ਕਰੋ। ਕੀ ਨਵੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹਨ? ਕੀ ਆਉਟਪੁੱਟ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਕੋਡਬੇਸ ਦੇ ਸਮਾਨ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ?
6. ਜੇ ਇਹ ਸੁਰੱਖਿਆ-ਨਾਜ਼ੁਕ ਹੈ, ਤਾਂ ਮਾਹਰ ਦੀ ਪ੍ਰਵਾਨਗੀ ਲਈ ਪੁੱਛੋ। ਪ੍ਰਮਾਣਿਕਤਾ, ਭੁਗਤਾਨ, ਕ੍ਰਿਪਟੋਗ੍ਰਾਫੀ, ਪਹੁੰਚ ਨਿਯੰਤਰਣ ਵਰਗੇ ਖੇਤਰਾਂ ਵਿੱਚ ਸਮਰੱਥ ਇੰਜੀਨੀਅਰ ਦੁਆਰਾ ਸੁਤੰਤਰ ਸਮੀਖਿਆ ਲਾਜ਼ਮੀ ਹੈ।

ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ

ਕੇਸ 1 - ਨਿਰੀਖਣ ਗੇਟ 'ਤੇ ਫੜਿਆ ਗਿਆ SQL ਟੀਕਾ। AI ਤਿਆਰ ਕੀਤਾ ਕੋਡ ਜੋ ਖੋਜ ਅੰਤਮ ਬਿੰਦੂ ("... WHERE name = '" + q + "'") ਲਈ ਸਿੱਧੇ SQL ਪੁੱਛਗਿੱਛ ਵਿੱਚ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਨੂੰ ਜੋੜਦਾ ਹੈ। ਕੋਡ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ ਅਤੇ ਟੈਸਟ ਪਾਸ ਕੀਤਾ। ਸੁਰੱਖਿਆ-ਕੇਂਦ੍ਰਿਤ ਨਿਰੀਖਣ ਅਤੇ SAST ਸਕੈਨਿੰਗ ਨੇ ਇਸ ਨੂੰ ਫੜਿਆ; ਇਸਨੂੰ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ (ਤਿਆਰ ਸਟੇਟਮੈਂਟ) ਵਿੱਚ ਬਦਲਿਆ ਗਿਆ ਸੀ। ਜੇਕਰ ਇਹ ਫੜਿਆ ਨਾ ਗਿਆ ਹੁੰਦਾ, ਤਾਂ ਇਹ ਇੱਕ ਕਲਾਸਿਕ ਡਾਟਾ ਲੀਕ ਕਮਜ਼ੋਰੀ ਹੋਣੀ ਸੀ।

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

ਕੇਸ 3 — ਲਾਇਸੈਂਸ ਅਸੰਗਤਤਾ। AI ਦੁਆਰਾ ਸੁਝਾਈ ਗਈ ਇੱਕ ਨਿਫਟੀ ਸਾਥੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਕਾਪੀਲੈਫਟ ਲਾਇਸੈਂਸ ਸੀ ਜੋ ਸੰਸਥਾ ਦੇ ਉਤਪਾਦ ਲਾਇਸੰਸ ਦੇ ਅਨੁਕੂਲ ਨਹੀਂ ਸੀ। ਨਿਰਭਰਤਾ ਲਾਇਸੈਂਸ ਸਕੈਨ ਨੇ ਇਸਦੀ ਰਿਪੋਰਟ ਕੀਤੀ; ਟੀਮ ਨੇ ਲਾਇਸੈਂਸ ਨੂੰ ਢੁਕਵਾਂ ਬਦਲ ਦਿੱਤਾ। ਤਸਦੀਕ ਕੀਤੇ ਬਿਨਾਂ, ਉਤਪਾਦ ਦੀ ਵੰਡ ਵਿੱਚ ਇੱਕ ਕਾਨੂੰਨੀ ਬੋਝ ਪੈਦਾ ਹੋਵੇਗਾ।

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਨਮੂਨੇ

ਦਾਖਲੇ ਤੋਂ ਪਹਿਲਾਂ ਸਵੈ-ਜਾਂਚ:

ਹੇਠਾਂ ਦਿੱਤੇ AI ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਜਾਂਚ ਕਰੋ: 1) ਕੀ ਹਰ ਫੰਕਸ਼ਨ/API/ਪੈਕੇਜ ਜੋ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹੈ? ਸ਼ੱਕੀਆਂ ਨੂੰ ਫਲੈਗ ਕਰੋ। 2) ਕੀ ਕੋਈ ਗੈਰ-ਪ੍ਰਮਾਣਿਤ ਇਨਪੁਟ, SQL/ਕਮਾਂਡ ਜੋੜ, ਦਫ਼ਨਾਇਆ ਗਿਆ ਸੀਕ੍ਰੇਟ, ਕਮਜ਼ੋਰ ਕ੍ਰਿਪਟੋ ਹੈ? 3) ਅਣਐਡਰੈੱਸਡ ਬੱਗ/ਐਜ ਕੇਸ ਕੀ ਹਨ? ਹਰ ਇੱਕ ਖੋਜ ਨੂੰ "ਕੁਝ/ਸੰਭਾਵੀ" ਵਜੋਂ ਲੇਬਲ ਕਰੋ ਅਤੇ ਸੁਧਾਰਾਂ ਦਾ ਸੁਝਾਅ ਦਿਓ।{{code}}

ਸੁਰੱਖਿਆ ਕੇਂਦਰਿਤ ਸਮੀਖਿਆ:

ਸੁਰੱਖਿਆ ਅੱਖ ਨਾਲ ਇਸ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ। ਆਮ OWASP ਸ਼ੈਲੀ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਭਾਲ ਕਰੋ: ਇੰਜੈਕਸ਼ਨ, ਟੁੱਟੀ ਹੋਈ ਪ੍ਰਮਾਣਿਕਤਾ/ਪ੍ਰਮਾਣੀਕਰਨ, ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਖੁਲਾਸਾ, ਅਸੁਰੱਖਿਅਤ ਡੀਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ, ਅਣ-ਪ੍ਰਮਾਣਿਤ ਰੀਡਾਇਰੈਕਸ਼ਨ। ਹਰੇਕ ਖੋਜ ਲਈ: ਜੋਖਮ, ਸ਼ੋਸ਼ਣ ਦ੍ਰਿਸ਼, ਉਪਚਾਰ। ਇਹ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਸਕ੍ਰੀਨਿੰਗ ਹੈ; ਮਨੁੱਖੀ ਸੁਰੱਖਿਆ ਸਮੀਖਿਆ ਲਈ ਮਹੱਤਵਪੂਰਨ ਖੋਜਾਂ ਦਾ ਹਵਾਲਾ ਦਿਓ।{{code}}

ਨਿਰਭਰਤਾ ਅਤੇ ਲਾਇਸੈਂਸ ਜਾਂਚ:

ਇਸ ਕੋਡ ਦੁਆਰਾ ਜੋੜੀਆਂ/ਸੁਝਾਈਆਂ ਗਈਆਂ ਨਿਰਭਰਤਾਵਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ। ਹਰੇਕ ਲਈ: ਕੀ ਪੈਕੇਜ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹੈ, ਕੀ ਇਸਦਾ ਰੱਖ-ਰਖਾਅ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸਦਾ ਆਮ ਲਾਇਸੈਂਸ ਕੀ ਹੋਵੇਗਾ (ਤਸਦੀਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ), ਅਤੇ ਕੀ ਇਹ ਅਸਲ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਲਈ ਲੋੜੀਂਦਾ ਹੈ ਜਾਂ ਕੀ ਇਸਨੂੰ ਮੌਜੂਦਾ ਟੂਲ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ?{{ਕੋਡ ਜਾਂ ਨਿਰਭਰਤਾ ਸੂਚੀ}}

ਸੁਰੱਖਿਅਤ ਫਾਰਮਵਰਕ ਲਗਾਉਣਾ (ਉਤਪਾਦਨ ਵਿੱਚ):

{{task}} ਲਈ ਕੋਡ ਲਿਖੋ। ਲਾਜ਼ਮੀ ਸੁਰੱਖਿਆ ਨਿਯਮ:- ਸਾਰੇ ਬਾਹਰੀ ਇਨਪੁਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ/ਸੈਨੀਟਾਈਜ਼ ਕਰੋ।- ਡੇਟਾਬੇਸ ਐਕਸੈਸ ਵਿੱਚ ਸਿਰਫ਼ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰੋ।- ਕੋਡ ਵਿੱਚ ਭੇਦ ਏਮਬੇਡ ਨਾ ਕਰੋ; ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ/ਗੁਪਤ ਪ੍ਰਬੰਧਕ ਮੰਨੋ - ਗਲਤੀਆਂ ਨੂੰ ਨਿਗਲ ਨਾ ਕਰੋ; ਇਸ ਨੂੰ ਅਰਥਪੂਰਨ ਤੌਰ 'ਤੇ ਵਿਚਾਰੋ। ਸਮਝਾਓ ਕਿ ਕੋਡ 3 ਆਈਟਮਾਂ ਵਿੱਚ ਇਹਨਾਂ ਨਿਯਮਾਂ ਦੀ ਪਾਲਣਾ ਕਿਵੇਂ ਕਰਦਾ ਹੈ।

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

ਕਮਜ਼ੋਰ: "ਉਪਭੋਗਤਾ ਨਾਮ ਦੁਆਰਾ ਖੋਜਣ ਵਾਲੀ ਪੁੱਛਗਿੱਛ ਲਿਖੋ।" (ਇੰਜੈਕਸ਼ਨ ਲਈ ਕਮਜ਼ੋਰ ਕੋਡ ਹੋ ਸਕਦਾ ਹੈ।)

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

ਮਜ਼ਬੂਤ ​​ਸੰਸਕਰਣ ਸ਼ੁਰੂ ਤੋਂ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਲਗਾਉਂਦਾ ਹੈ; ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਬਾਅਦ ਵਿੱਚ ਇਸ ਨੂੰ ਫੜਨ ਦੀ ਬਜਾਏ, ਕਮਜ਼ੋਰੀ ਬਿਲਕੁਲ ਨਹੀਂ ਵਾਪਰਦੀ। ਹਾਲਾਂਕਿ, ਵੈਰੀਫਿਕੇਸ਼ਨ ਗੇਟਾਂ ਰਾਹੀਂ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਪਾਸ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।

ਪ੍ਰਮਾਣੀਕਰਨ ਪਰਤ

ਸੰਦ/ਵਿਧੀ

ਕੀ "AI ਕਿਹਾ" ਕਾਫ਼ੀ ਹੈ?

ਸ਼ੁੱਧਤਾ

ਸੰਕਲਨ, ਟੈਸਟਿੰਗ, ਵਿਜ਼ੂਅਲ ਨਿਰੀਖਣ

ਨਹੀਂ

API/ਪੈਕੇਜ ਅਸਲੀਅਤ

ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼/ਰਿਕਾਰਡ ਨਿਯੰਤਰਣ

ਨਹੀਂ

ਸੁਰੱਖਿਆ

SAST, ਸੁਰੱਖਿਆ ਸਮੀਖਿਆ

ਨਹੀਂ

ਲਾਇਸੰਸ/ਸਰੋਤ

ਨਿਰਭਰਤਾ ਅਤੇ ਲਾਇਸੈਂਸ ਜਾਂਚ

ਨਹੀਂ

ਸੁਰੱਖਿਆ-ਨਾਜ਼ੁਕ ਤਰਕ

ਮਾਹਰ ਇੰਜੀਨੀਅਰ ਦੀ ਪ੍ਰਵਾਨਗੀ

ਬਿਲਕੁਲ ਨਹੀਂ

ਜ਼ਿੰਮੇਵਾਰੀ ਦਾ ਤਬਾਦਲਾ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ

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

ਸੰਕੇਤ: ਆਪਣੀ ਟੀਮ 'ਤੇ ਇੱਕ ਛੋਟੀ ਚੈਕਲਿਸਟ ਬਣਾਓ ਜਿਸ ਨੂੰ ਤੁਸੀਂ "AI-ਜਨਰੇਟ ਕੋਡ ਲਈ ਪ੍ਰਮਾਣਿਕਤਾ ਗੇਟ" ਕਹਿੰਦੇ ਹੋ (ਬਿਲਡ + ਟੈਸਟ + ਸੁਰੱਖਿਆ ਸਕੈਨ + ਵਿਜ਼ੂਅਲ ਇੰਸਪੈਕਸ਼ਨ)। ਇੱਕ ਵਾਰ ਜਦੋਂ ਇਹ ਗੇਟ ਇੱਕ ਆਦਤ ਬਣ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਗਤੀ ਦਾ ਨੁਕਸਾਨ ਘੱਟ ਹੁੰਦਾ ਹੈ ਅਤੇ ਜੋਖਮ ਘਟਾਉਣਾ ਵੱਧ ਤੋਂ ਵੱਧ ਹੁੰਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• "ਸੁਰੱਖਿਅਤ" ਨਾਲ "ਕੰਮ" ਨੂੰ ਉਲਝਾਉਣਾ. ਟੈਸਟਿੰਗ ਪਾਸ ਕਰਨ ਵਾਲਾ ਕੋਡ ਹਮਲੇ ਲਈ ਕਮਜ਼ੋਰ ਹੋ ਸਕਦਾ ਹੈ।
• ਬਿਨਾਂ ਪੁਸ਼ਟੀ ਕੀਤੇ ਪੈਕੇਜ/API ਦੀ ਵਰਤੋਂ ਕਰਨਾ। ਹੈਲੁਸੀਨੇਟਰੀ ਪੈਕੇਟ ਦੋਵੇਂ ਭ੍ਰਿਸ਼ਟ ਅਤੇ ਸੁਰੱਖਿਆ ਖਤਰਾ ਪੈਦਾ ਕਰਦੇ ਹਨ।
• ਆਟੋਮੇਟਿਡ ਟੂਲਸ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨਾ। ਲਿੰਟਰ, ਟਾਈਪ ਚੈਕਰ ਅਤੇ SAST ਸਸਤੇ ਤਰੀਕੇ ਨਾਲ ਫੜਦੇ ਹਨ ਜੋ ਇਨਸਾਨ ਗੁਆ ​​ਬੈਠਦੇ ਹਨ।
• ਲਾਇਸੈਂਸ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ। ਗਲਤ ਲਾਇਸੰਸਸ਼ੁਦਾ ਨਿਰਭਰਤਾ ਵੰਡ 'ਤੇ ਕਾਨੂੰਨੀ ਬੋਝ ਪੈਦਾ ਕਰਦੀ ਹੈ।
• ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਗੱਡੀ 'ਤੇ ਪਾ ਦਿੱਤੀ। ਟੀਮ ਉਤਪਾਦਨ ਵਿੱਚ ਕੋਡ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ; "ਏਆਈ ਨੇ ਇਹ ਕੀਤਾ" ਕੋਈ ਬਹਾਨਾ ਨਹੀਂ ਹੈ.

ਸੰਖੇਪ ਵਿੱਚ

AI ਆਉਟਪੁੱਟ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਲਈ ਤਸਦੀਕ ਦੀਆਂ ਤਿੰਨ ਪਰਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ: ਸ਼ੁੱਧਤਾ (ਕੰਪਾਈਲ, ਟੈਸਟ, ਵਿਜ਼ੂਅਲ ਨਿਰੀਖਣ), ਸੁਰੱਖਿਆ (SAST ਅਤੇ ਸੁਰੱਖਿਆ-ਕੇਂਦ੍ਰਿਤ ਸਮੀਖਿਆ), ਅਤੇ ਸਰੋਤ/ਲਾਈਸੈਂਸ (ਨਿਰਭਰਤਾ ਜਾਂਚ)। ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਵਰਤੇ ਗਏ ਹਰੇਕ ਪੈਕੇਜ ਅਤੇ API ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹਨ, ਸ਼ੁਰੂ ਤੋਂ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਲਾਗੂ ਕਰੋ, ਅਤੇ ਇੱਕ ਯੋਗਤਾ ਪ੍ਰਾਪਤ ਇੰਜੀਨੀਅਰ ਦੁਆਰਾ ਪ੍ਰਵਾਨਗੀ ਲਈ ਸੁਰੱਖਿਆ-ਨਾਜ਼ੁਕ ਕੋਡ ਜਮ੍ਹਾਂ ਕਰੋ। "ਕੰਮਾਂ" ਦਾ ਮਤਲਬ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਹੈ, ਅਤੇ "ਏਆਈ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ" ਦੇਣਦਾਰੀ ਨੂੰ ਨਹੀਂ ਹਟਾਉਂਦਾ ਹੈ। ਤਸਦੀਕ ਗੇਟ ਪੇਸ਼ੇਵਰਤਾ ਦੀ ਕੀਮਤ ਹੈ, ਨਾ ਕਿ ਗਤੀ.

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

ਜਾਣਬੁੱਝ ਕੇ ਇੱਕ AI ਨੂੰ ਇੱਕ ਸੁਰੱਖਿਆ-ਸੰਵੇਦਨਸ਼ੀਲ ਕੰਮ ਦਿਓ (ਉਦਾਹਰਨ ਲਈ, "ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਉਪਭੋਗਤਾ ਇਨਪੁਟ ਨਾਲ ਡੇਟਾਬੇਸ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ"), ਇਸ ਵਾਰ ਇੱਕ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਲਗਾਏ ਬਿਨਾਂ। "ਪ੍ਰੀ-ਐਡਮਿਸ਼ਨ ਸਵੈ-ਆਡਿਟ" ਅਤੇ "ਸੁਰੱਖਿਆ-ਕੇਂਦ੍ਰਿਤ ਸਮੀਖਿਆ" ਟੈਂਪਲੇਟਸ ਦੁਆਰਾ ਇਨਕਮਿੰਗ ਕੋਡ ਪਾਸ ਕਰੋ: ਕੀ ਇੱਥੇ ਕੋਈ ਟੀਕਾ, ਦੱਬਿਆ ਗੁਪਤ, ਭਰਮ ਵਾਲਾ ਪੈਕੇਟ, ਜਾਂ ਅਣ-ਪ੍ਰਮਾਣਿਤ ਇਨਪੁਟ ਹੈ? ਫਿਰ "ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਲਗਾਉਣ" ਟੈਂਪਲੇਟ ਨਾਲ ਉਸੇ ਕੰਮ ਨੂੰ ਦੁਬਾਰਾ ਪੁੱਛੋ ਅਤੇ ਦੋ ਆਉਟਪੁੱਟਾਂ ਦੀ ਤੁਲਨਾ ਕਰੋ। ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਲਿੰਟਰ/SAST ਟੂਲ ਚਲਾਓ ਅਤੇ ਖੋਜਾਂ ਦੀ AI ਦੇ ਸਵੈ-ਨਿਯਮ ਨਾਲ ਤੁਲਨਾ ਕਰੋ।

ਚੈੱਕਲਿਸਟ

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