ਸੁਰੱਖਿਅਤ ਕੋਡ ਸਮੀਖਿਆ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ: ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ ਨਾਲ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ

ਲਾਭ:

• ਸੰਦਰਭ ਦੇ ਕੇ ਕੋਡ ਵਿੱਚ ਦੂਜੀ ਅੱਖ ਦੇ ਤੌਰ ਤੇ ਨਕਲੀ ਬੁੱਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਅਤੇ OWASP ਸ਼੍ਰੇਣੀ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ (ਇੰਜੈਕਸ਼ਨ, ਹਾਰਡ ਸੀਕਰੇਟ, ਐਕਸੈਸ ਕੰਟਰੋਲ) ਨੂੰ ਫਲੈਗ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਸੰਦਰਭ ਦੇ ਨਾਲ ਨਕਲੀ ਬੁੱਧੀ ਦੁਆਰਾ ਪੈਦਾ ਕੀਤੇ ਗਏ ਝੂਠੇ ਸਕਾਰਾਤਮਕ ਤੱਤਾਂ ਨੂੰ ਖਤਮ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਹਰੇਕ ਖੋਜ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਅਸਲ ਕਮਜ਼ੋਰੀ ਦੇ ਰੂਪ ਵਿੱਚ ਇਲਾਜ ਕਰਨ ਤੋਂ ਰੋਕਣ ਦੀ ਸਮਰੱਥਾ
• ਇਹ ਪਛਾਣ ਕਰਨ ਦੀ ਯੋਗਤਾ ਕਿ ਨਕਲੀ ਬੁੱਧੀ ਦੁਆਰਾ ਸੁਝਾਏ ਗਏ ਫਿਕਸ ਨਵੇਂ ਕਮਜ਼ੋਰੀਆਂ/ਬੱਗਾਂ ਨੂੰ ਪੇਸ਼ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਹਰੇਕ ਪੈਚ ਨੂੰ ਸਮੀਖਿਆ ਅਤੇ ਟੈਸਟਿੰਗ ਗੇਟ ਰਾਹੀਂ ਪਾਸ ਕਰ ਸਕਦੇ ਹਨ

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

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

ਕੋਡ ਸਮੀਖਿਆ ਦੇ ਪੜਾਅ

1. ਦਾਇਰਾ ਅਤੇ ਸੰਦਰਭ ਦਿਓ। ਕਿਹੜੀ ਭਾਸ਼ਾ, ਕਿਹੜਾ ਫਰੇਮਵਰਕ, ਇਹ ਕੋਡ ਇਨਪੁਟ ਕਿੱਥੋਂ ਲੈਂਦਾ ਹੈ, ਇਹ ਆਉਟਪੁੱਟ ਕਿੱਥੇ ਦਿੰਦਾ ਹੈ, ਇਹ ਕਿਸ ਲੇਅਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ? ਸੰਦਰਭ ਤੋਂ ਬਿਨਾਂ ਕੋਡ ਸਮੀਖਿਆ ਗਲਤ ਸਕਾਰਾਤਮਕ ਪੈਦਾ ਕਰਦੀ ਹੈ।
2. ਖਤਰਨਾਕ ਪੈਟਰਨਾਂ ਲਈ ਸਕੈਨ ਕਰੋ। ਜਾਣੇ-ਪਛਾਣੇ AI ਕਮਜ਼ੋਰੀ ਦੀਆਂ ਕਲਾਸਾਂ (ਜਿਵੇਂ ਕਿ OWASP ਸਿਖਰ 10) ਲਈ ਖੋਜ ਕਰੋ: ਇੰਜੈਕਸ਼ਨ, ਪ੍ਰਮਾਣਿਕਤਾ, ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਖੁਲਾਸਾ, ਪਹੁੰਚ ਨਿਯੰਤਰਣ।
3. ਹਰੇਕ ਖੋਜ ਨੂੰ ਜਾਇਜ਼ ਠਹਿਰਾਓ। ਹਰੇਕ ਝੰਡੇ ਲਈ: ਕਿਹੜੀ ਲਾਈਨ, ਕਿਹੜੀ ਕਮਜ਼ੋਰ ਸ਼੍ਰੇਣੀ, ਇਸਦਾ ਸ਼ੋਸ਼ਣ ਕਿਵੇਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਸਬੂਤ ਕੀ ਹੈ। ਅਣਉਚਿਤ ਖੋਜ ਨੂੰ ਗੰਭੀਰਤਾ ਨਾਲ ਨਹੀਂ ਲਿਆ ਜਾਂਦਾ ਹੈ।
4. ਝੂਠੇ ਸਕਾਰਾਤਮਕ ਨੂੰ ਖਤਮ ਕਰੋ. ਕੀ ਇਨਪੁਟ ਅਸਲ ਵਿੱਚ ਸਾਫ਼ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਕੀ ਉਹ ਮਾਰਗ ਅਸਲ ਵਿੱਚ ਪਹੁੰਚਯੋਗ ਹੈ - ਸੰਦਰਭ ਨਾਲ ਜਾਂਚ ਕਰੋ।
5. ਫਿਕਸ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ AI ਦੁਆਰਾ ਸਿਫ਼ਾਰਿਸ਼ ਕੀਤਾ ਗਿਆ ਪੈਚ ਅਸਲ ਵਿੱਚ ਕਮਜ਼ੋਰੀ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ, ਨਵੀਆਂ ਕਮਜ਼ੋਰੀਆਂ/ਬੱਗਾਂ ਨੂੰ ਪੇਸ਼ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਟੈਸਟਿੰਗ ਪਾਸ ਕਰ ਚੁੱਕਾ ਹੈ।
6. ਮਨੁੱਖੀ ਪ੍ਰਵਾਨਗੀ. ਡਿਵੈਲਪਰ + ਸੁਰੱਖਿਆ ਮਾਹਰ ਖੋਜ ਅਤੇ ਫਿਕਸ ਦੀ ਸਮੀਖਿਆ ਕਰਦਾ ਹੈ; ਇਸ ਤਰ੍ਹਾਂ ਇਹ ਕੋਡ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ।

ਸ਼ਰਤਾਂ: SAST (ਸਟੈਟਿਕ ਐਪਲੀਕੇਸ਼ਨ ਸਕਿਓਰਿਟੀ ਟੈਸਟਿੰਗ — ਸਥਿਰ ਸੁਰੱਖਿਆ ਟੈਸਟਿੰਗ ਜੋ ਸਰੋਤ ਕੋਡ ਨੂੰ ਚਲਾਏ ਬਿਨਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੀ ਹੈ)। DAST (ਡਾਇਨੈਮਿਕ — ਡਾਇਨਾਮਿਕ ਟੈਸਟਿੰਗ ਜੋ ਚੱਲ ਰਹੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬਾਹਰੋਂ ਟੈਸਟ ਕਰਦੀ ਹੈ)। OWASP ਸਿਖਰ 10 ਸਭ ਤੋਂ ਆਮ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਮਿਆਰੀ ਸੂਚੀ ਹੈ। ਇੰਜੈਕਸ਼ਨ ਇੱਕ ਕਮਜ਼ੋਰੀ ਹੈ ਜੋ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਕਮਾਂਡ/ਕਵੇਰੀ (ਜਿਵੇਂ ਕਿ SQL ਇੰਜੈਕਸ਼ਨ) ਦੇ ਰੂਪ ਵਿੱਚ ਵਿਆਖਿਆ ਕਰਨ ਕਾਰਨ ਹੁੰਦੀ ਹੈ। ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਇੱਕ ਸਹੀ ਤਰੀਕਾ ਹੈ ਜੋ ਕੋਡ ਤੋਂ ਇੰਪੁੱਟ ਨੂੰ ਵੱਖ ਕਰਕੇ ਇੰਜੈਕਸ਼ਨ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਆਮ ਕਮਜ਼ੋਰੀ ਵਰਗਾਂ ਦੀ ਸਾਰਣੀ

ਕਮਜ਼ੋਰੀ ਵਰਗ

ਲੱਛਣ (ਕੋਡ ਵਿੱਚ)

ਸਹੀ ਹੱਲ

AI ਦਾ ਜਾਲ

SQL ਟੀਕਾ

ਪੁੱਛਗਿੱਛ ਵਿੱਚ ਇਨਪੁਟ ਸ਼ਾਮਲ ਹੋ ਰਿਹਾ ਹੈ

ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ

ਸਵੱਛਤਾ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਸਕਦਾ ਹੈ

ਹਾਰਡ ਕੋਡਿਡ ਗੁਪਤ

ਕੋਡ ਵਿੱਚ ਪਾਸਵਰਡ/ਕੁੰਜੀ

ਸੀਕਰੇਟ ਸੇਫ (ਵਾਲਟ), env

ਗਲਤ ਸਕਾਰਾਤਮਕ (ਨਮੂਨਾ/ਟੈਸਟ)

ਕਮਜ਼ੋਰ ਪ੍ਰਮਾਣਿਕਤਾ

ਗੁੰਮ/ਗਲਤ ਕੰਟਰੋਲ

ਸ਼ਕਤੀਸ਼ਾਲੀ, ਕੇਂਦਰੀਕ੍ਰਿਤ ਨਿਯੰਤਰਣ

ਪ੍ਰਸੰਗ ਖੁੰਝ ਜਾਂਦਾ ਹੈ

ਨੁਕਸਦਾਰ ਪਹੁੰਚ ਨਿਯੰਤਰਣ

ਕੋਈ ਅਧਿਕਾਰ ਜਾਂਚ ਨਹੀਂ

ਸਰਵਰ ਸਾਈਡ ਅਧਿਕਾਰ

ਗੁੰਝਲਦਾਰ ਪ੍ਰਵਾਹ ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ

ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਦਾ ਖੁਲਾਸਾ

ਪਾਸਵਰਡ-ਮੁਕਤ ਸਟੋਰੇਜ/ਲੌਗਿੰਗ

ਏਨਕ੍ਰਿਪਸ਼ਨ, ਮਾਸਕਿੰਗ

ਨਾਜ਼ੁਕਤਾ ਨੂੰ ਨਹੀਂ ਜਾਣ ਸਕਦਾ

ਅਸੁਰੱਖਿਅਤ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ

ਗੈਰ-ਭਰੋਸੇਯੋਗ ਡੇਟਾ ਨੂੰ ਡੀਸੀਰੀਅਲਾਈਜ਼ ਕਰੋ

ਸੁਰੱਖਿਅਤ ਪਾਰਸਿੰਗ

ਦੁਰਲੱਭ ਪੈਟਰਨ ਖੁੰਝ ਜਾਂਦਾ ਹੈ

ਤਿੰਨ ਛੋਟੇ ਕੇਸ

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

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

ਕੇਸ 3 - ਨਵੀਂ ਕਮਜ਼ੋਰੀ ਫਿਕਸ। AI ਇੱਕ XSS (ਕਰਾਸ-ਸਾਈਟ ਸਕ੍ਰਿਪਟਿੰਗ) ਕਮਜ਼ੋਰੀ ਲਈ ਇੱਕ ਫਿਕਸ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹੈ; ਪਰ ਕੋਡ ਜੋ ਉਹ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ, ਗਲਤ ਥਾਂ 'ਤੇ ਇੰਪੁੱਟ ਨੂੰ ਸਾਫ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਹੋਰ ਖੇਤਰ ਵਿੱਚ ਆਉਟਪੁੱਟ ਏਨਕੋਡਿੰਗ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ; ਨਤੀਜੇ ਵਜੋਂ, ਪਾੜਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬੰਦ ਨਹੀਂ ਹੁੰਦਾ. ਸੁਰੱਖਿਆ ਮਾਹਰ ਫਿਕਸ ਦੀ ਸਮੀਖਿਆ ਕਰਦਾ ਹੈ, ਗੁੰਮ ਕੋਡਿੰਗ ਨੂੰ ਨੋਟਿਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਸਹੀ ਪਰਤ 'ਤੇ ਠੀਕ ਕਰਦਾ ਹੈ। ਪਾਠ: AI ਦੁਆਰਾ ਸਿਫ਼ਾਰਿਸ਼ ਕੀਤੀ ਗਈ ਪੈਚ ਆਪਣੇ ਆਪ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਹੈ; ਹਰ ਫਿਕਸ ਦੀ ਸਮੀਖਿਆ ਅਤੇ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.

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

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ:

ਕੀ ਇਸ ਕੋਡ ਵਿੱਚ ਕੋਈ ਕਮੀ ਹੈ, ਇਸਨੂੰ ਠੀਕ ਕਰੋ: [code]

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

ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰਾਉਟ:

ਤੁਹਾਡੀ ਭੂਮਿਕਾ: ਸਹਾਇਕ ਜੋ ਸੁਰੱਖਿਅਤ ਕੋਡ ਸਮੀਖਿਆ ਵਿੱਚ ਡਿਵੈਲਪਰ ਲਈ ਦੂਜੀ ਅੱਖ ਹੈ। ਫੈਸਲਾ ਲੈਣਾ; ਸਿੱਧੇ ਲਾਗੂ ਕੀਤੇ ਫਿਕਸ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਕੋਡ: [ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ ਨਿਰਧਾਰਤ ਕਰੋ]।ਪ੍ਰਸੰਗ: ਇਹ ਫੰਕਸ਼ਨ [ਇਨਪੁਟ ਸਰੋਤ: ਉਦਾਹਰਨ ਲਈ [ਬਾਹਰੀ HTTP ਬੇਨਤੀ] ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, [ਆਉਟਪੁੱਟ ਮੰਜ਼ਿਲ] ਨੂੰ ਲਿਖਦਾ ਹੈ। ਤੁਹਾਡਾ ਕੰਮ: (1) OWASP ਕਲਾਸ ਨਾਲ ਸੰਭਾਵਿਤ ਕਮਜ਼ੋਰੀਆਂ ਨੂੰ ਫਲੈਗ ਕਰੋ, ਹਰੇਕ ਲਈ ਲਾਈਨ ਨੰਬਰ + ਕਿਉਂ ਜੋਖਮ ਭਰਿਆ + ਕਿਵੇਂ ਸ਼ੋਸ਼ਣ ਕਰਨਾ ਹੈ + ਸਬੂਤ ਦਿਓ, (2) ਹਰੇਕ ਖੋਜ ਲਈ ਘੱਟੋ-ਘੱਟ 1 ਗਲਤ ਸਕਾਰਾਤਮਕ ਦ੍ਰਿਸ਼ ਲਿਖੋ (ਜਿਵੇਂ ਕਿ ਜੇਕਰ ਇਨਪੁਟ ਕਿਸੇ ਹੋਰ ਲੇਅਰ ਵਿੱਚ ਰੋਗਾਣੂ-ਮੁਕਤ ਹੈ), (3) ਇੱਕ ਹੱਲ ਦਾ ਸੁਝਾਅ ਦਿਓ ਪਰ "[ਸਮੀਖਿਆ + ਲਿਖੋ ਟੈਸਟ]" ਚਿੰਨ੍ਹ ਨਾਲ; ਇਹ ਵੀ ਮੁਲਾਂਕਣ ਕਰੋ ਕਿ ਕੀ ਫਿਕਸ ਨਵੀਆਂ ਕਮਜ਼ੋਰੀਆਂ/ਬੱਗਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਇੱਕ ਜਾਅਲੀ ਕਮਜ਼ੋਰੀ ਸ਼ਾਮਲ ਕਰਨਾ।[ਕੋਡ]

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

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

ਕਮਜ਼ੋਰੀ ਸਕੈਨ ਟੈਂਪਲੇਟ OWASP ਸਿਖਰ 10 ਲਈ [ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ] ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ। ਹਰੇਕ ਸੰਭਾਵੀ ਖੋਜ ਲਈ: ਲਾਈਨ ਨੰਬਰ, ਕਮਜ਼ੋਰੀ ਸ਼੍ਰੇਣੀ, ਇਹ ਜੋਖਮ ਭਰਿਆ ਕਿਉਂ ਹੈ, ਨਮੂਨਾ ਸ਼ੋਸ਼ਣ, ਸਬੂਤ ਦੀ ਤਾਕਤ (ਕੁਝ/ਸੰਭਾਵਿਤ/ਕਮਜ਼ੋਰ)। ਸੰਦਰਭ: ਇਨਪੁਟ [ਸਰੋਤ], ਆਉਟਪੁੱਟ [ਨਿਸ਼ਾਨਾ]। ਮਨਘੜਤ ਖੋਜਾਂ ਨੂੰ ਜੋੜਨਾ; ਜੇਕਰ ਤੁਹਾਨੂੰ ਪੱਕਾ ਪਤਾ ਨਹੀਂ ਹੈ, ਤਾਂ ਟਾਈਪ ਕਰੋ "[ਪੁਸ਼ਟੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ]"। ਕੋਡ: [ਪੇਸਟ]

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

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

ਕਮਜ਼ੋਰੀ ਸ਼੍ਰੇਣੀ ਲਈ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਟੀਚਿੰਗ ਟੈਂਪਲੇਟ [ਉਦਾ. SQL ਇੰਜੈਕਸ਼ਨ] ਤੁਲਨਾਤਮਕ ਤੌਰ 'ਤੇ ਇਸ ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਟਾਈਪਿੰਗ ਪੈਟਰਨ ਅਤੇ ਆਮ ਗਲਤ ਪੈਟਰਨ ਦਿਖਾਉਂਦੇ ਹਨ। ਆਮ ਨਿਯਮ + ਕੋਡ ਉਦਾਹਰਨ ਦਿਓ; ਪਰ ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਮੇਰੇ ਕੋਡ ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸੰਦਰਭ ਨੂੰ ਪੁੱਛੋ. ਭਾਸ਼ਾ/ਫਰੇਮਵਰਕ: [ਲਿਖੋ]

ਆਮ ਗਲਤੀਆਂ

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

ਸੰਕੇਤ: ਜਦੋਂ AI ਸਮੀਖਿਆ ਕੋਡ ਹੋਵੇ, ਤਾਂ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਫਿਲਟਰ ਹਰੇਕ ਖੋਜ ਲਈ "ਸਬੂਤ ਦੀ ਤਾਕਤ" (ਕੁਝ/ਸੰਭਾਵਿਤ/ਕਮਜ਼ੋਰ) ਦੀ ਮੰਗ ਕਰਨਾ ਹੈ। "ਕਮਜ਼ੋਰ" ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਜ਼ਿਆਦਾਤਰ ਖੋਜਾਂ ਝੂਠੇ ਸਕਾਰਾਤਮਕ ਹਨ; ਤੁਸੀਂ ਆਪਣੀ ਊਰਜਾ ਨੂੰ "ਪੱਕੇ" ਲੋਕਾਂ ਨੂੰ ਵੰਡਦੇ ਹੋ।

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

ਸਾਰੰਸ਼ ਵਿੱਚ

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

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

ਇੱਕ ਨਮੂਨਾ ਕੋਡ ਸਨਿੱਪਟ ਲਓ (ਜਾਂ ਤਾਂ ਆਪਣੇ ਖੁਦ ਦੇ ਕੋਡ ਤੋਂ ਸੰਵੇਦਨਸ਼ੀਲ ਭਾਗਾਂ ਨੂੰ ਹਟਾਉਣਾ ਜਾਂ ਕਮਜ਼ੋਰੀਆਂ ਵਾਲਾ ਨਮੂਨਾ ਕੋਡ)। AI ਨੂੰ “Vulnerability Scanning” ਟੈਂਪਲੇਟ ਨਾਲ ਇਸਦੀ ਜਾਂਚ ਕਰੋ; ਹਰੇਕ ਖੋਜ ਲਈ "ਗਲਤ ਸਕਾਰਾਤਮਕ ਖਾਤਮੇ" ਟੈਂਪਲੇਟ ਨੂੰ ਲਾਗੂ ਕਰੋ ਅਤੇ ਅਸਲ ਨੂੰ ਖਤਮ ਕਰੋ। "ਰਿਮੀਡੀਏਸ਼ਨ ਇਵੈਲੂਏਸ਼ਨ" ਟੈਮਪਲੇਟ ਨਾਲ ਸਭ ਤੋਂ ਗੰਭੀਰ ਖੋਜਾਂ ਨੂੰ ਸੁਧਾਰੋ, ਇਸਦੀ ਖੁਦ ਸਮੀਖਿਆ ਕਰੋ ਅਤੇ ਇੱਕ ਸਕਾਰਾਤਮਕ + ਇੱਕ ਨਕਾਰਾਤਮਕ ਟੈਸਟ ਕੇਸ ਲਿਖੋ। ਨੋਟ ਕਰੋ ਕਿ ਕਿੰਨੀਆਂ ਖੋਜਾਂ ਝੂਠੇ ਸਕਾਰਾਤਮਕ ਸਨ।

ਚੈੱਕਲਿਸਟ

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