ਜੇ ਤੁਹਾਨੂੰ ਇਸਤੇਮਾਲ ਸਟ੍ਰਿਪਚਾਰ ਯੂਜ਼ਰ ਇਨਪੁਟ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਇਕੱਲੇ ਨਹੀਂ ਹੋ। ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਇਸ ਕਿਸਮ ਦੇ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਇਨਪੁੱਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਟੀਕੇ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਰੋਕਣ ਲਈ। ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ, ਇਹ ਤਰਕਪੂਰਨ ਜਾਪਦਾ ਹੈ, ਖਤਰਨਾਕ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਓ, ਅਤੇ ਪੇਲੋਡ ਗਾਇਬ ਹੋ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਪਹੁੰਚ ਸੁਰੱਖਿਆ ਦੀ ਗਲਤ ਭਾਵਨਾ ਦਿੰਦੀ ਹੈ। ਅਸਲ ਵਿੱਚ, ਹਮਲਾਵਰ ਸਧਾਰਨ ਫਿਲਟਰਾਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਸਕਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਸਟ੍ਰਿਪਚਾਰ ਵਰਤ ਅਸਪਸ਼ਟ ਪੇਲੋਡ, ਏਨਕੋਡਿੰਗ, ਜਾਂ ਚਲਾਕ ਸੰਦਰਭ ਸਵਿਚਿੰਗ। ਇਸੇ ਲਈ ਸਮਾਰਟ ਡਿਵੈਲਪਰ ਇੱਥੇ ਨਹੀਂ ਰੁਕਦੇ। ਇਸ ਦੀ ਬਜਾਏ, ਉਹ ਵਰਤਦੇ ਹਨ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ, ਜੋ ਜੜ੍ਹ 'ਤੇ ਟੀਕੇ ਦੇ ਹਮਲਿਆਂ ਨੂੰ ਰੋਕਦੇ ਹਨ।
ਇਸ ਪੋਸਟ ਵਿੱਚ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਕਿਉਂ ਸਟ੍ਰਿਪਚਾਰ ਅਸਲ-ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਅਸਫਲਤਾਵਾਂ, ਹਮਲਾਵਰ ਇਹਨਾਂ ਫਿਲਟਰਾਂ ਦੀ ਦੁਰਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦੇ ਹਨ, ਅਤੇ ਅਸਲ ਵਿੱਚ ਕਿਹੜੇ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ ਕੰਮ ਕਰਦੇ ਹਨ। ਅਸੀਂ ਕੋਡ ਉਦਾਹਰਣਾਂ ਵਿੱਚੋਂ ਲੰਘਾਂਗੇ, ਆਮ ਬਾਈਪਾਸ ਤਕਨੀਕਾਂ ਦਿਖਾਵਾਂਗੇ, ਅਤੇ ਸਮਝਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਇਨਪੁੱਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਹਮੇਸ਼ਾ ਢਾਂਚਾਗਤ ਸੁਰੱਖਿਆਵਾਂ ਨਾਲ ਜੋੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ, ਨਹੀਂ ਤਾਂ ਤੁਸੀਂ ਕਮਜ਼ੋਰ ਰਹੋਗੇ।
ਕੀ ਸਟ੍ਰਿਪਚਾਰ ਅਸਲ ਵਿੱਚ ਕਰਦਾ ਹੈ (ਅਤੇ ਨਹੀਂ ਕਰਦਾ)
ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਵਰਤਦੇ ਹਨ stripchar ਜਾਂ ਯੂਜ਼ਰ ਇਨਪੁਟ ਤੋਂ ਅਸੁਰੱਖਿਅਤ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਸਮਾਨ ਫੰਕਸ਼ਨ। ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਵਿਰਾਮ ਚਿੰਨ੍ਹ, ਵਿਸ਼ੇਸ਼ ਚਿੰਨ੍ਹ, ਜਾਂ ਕੁਝ ਵੀ ਅਲਫਾਨਿਊਮੇਰਿਕ ਨਹੀਂ ਹਟਾਉਂਦਾ। ਪਹਿਲਾਂ, ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਲੱਗਦਾ ਹੈ ਇਨਪੁੱਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ, ਪਰ ਇਹ ਅਸਲ ਸੁਰੱਖਿਆ ਨਹੀਂ ਹੈ।
ਆਓ ਇਸਨੂੰ ਤੋੜਦੇ ਹਾਂ। ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਇੱਕ ਫੰਕਸ਼ਨ:
ਵਰਗੇ ਅੱਖਰ ਹਟਾਉਂਦਾ ਹੈ ', ", ਜ ;. ਤਾਂ, ਜੇਕਰ ਤੁਸੀਂ ਦਰਜ ਕਰਦੇ ਹੋ:
ਇਹ ਬਣ ਜਾਂਦਾ ਹੈ:
ਭਾਵੇਂ ਯੂਜ਼ਰ ਇਨਪੁੱਟ ਸਾਫ਼ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਹਮਲਾਵਰ ਅਜੇ ਵੀ ਸਿਰਫ਼ ਤਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ SQL ਪੇਲੋਡ ਇੰਜੈਕਟ ਕਰ ਸਕਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਐਪਲੀਕੇਸ਼ਨ ਸਟ੍ਰਿੰਗ ਕੰਕੇਟੇਨੇਸ਼ਨ ਰਾਹੀਂ ਪੁੱਛਗਿੱਛਾਂ ਬਣਾਉਂਦੀ ਹੈ। SQL ਇੰਜੈਕਸ਼ਨ ਨੂੰ ਸੱਚਮੁੱਚ ਰੋਕਣ ਲਈ, ਤੁਹਾਨੂੰ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛਾਂ ਅਤੇ ਸੰਦਰਭ-ਜਾਗਰੂਕ ਇਨਪੁਟ ਹੈਂਡਲਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਅੱਖਰ ਫਿਲਟਰ ਜਿਵੇਂ ਕਿ stripchar() ਬਸ ਕਾਫ਼ੀ ਨਹੀਂ ਹਨ।
ਯਕੀਨਨ, ਸਟ੍ਰਿਪਡ ਇਨਪੁੱਟ ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਲੱਗ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਪਹੁੰਚ ਖਤਰਨਾਕ ਤਰਕ ਨੂੰ ਬੇਅਸਰ ਨਹੀਂ ਕਰਦੀ, ਇਹ ਸਿਰਫ ਇਸਨੂੰ ਲਿਖਣ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲਦੀ ਹੈ। ਦਰਅਸਲ, ਹਮਲਾਵਰ ਅਕਸਰ ਪੇਲੋਡਾਂ ਨੂੰ ਏਨਕੋਡ ਕਰਕੇ, ਵ੍ਹਾਈਟਸਪੇਸ ਪਾ ਕੇ, ਜਾਂ ਹਟਾਏ ਗਏ ਅੱਖਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਹਾਡੇ ਫਿਲਟਰ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਾਈਪਾਸ ਕਰਨ ਲਈ ਰਣਨੀਤਕ ਤੌਰ 'ਤੇ ਇਸਦਾ ਫਾਇਦਾ ਉਠਾਉਂਦੇ ਹਨ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਟ੍ਰਿਪਚਾਰ ਨਾਜ਼ੁਕ ਸੰਦਰਭ ਦੀ ਘਾਟ ਹੈ। ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਇਨਪੁਟ ਡੇਟਾਬੇਸ, ਸ਼ੈੱਲ, ਜਾਂ ਬ੍ਰਾਊਜ਼ਰ ਵੱਲ ਜਾ ਰਿਹਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਸਹੀ ਐਸਕੇਪਿੰਗ ਜਾਂ ਏਨਕੋਡਿੰਗ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਮੰਜ਼ਿਲ ਨੂੰ ਜਾਣੇ ਬਿਨਾਂ ਇਨਪੁਟ ਨੂੰ ਸੈਨੀਟਾਈਜ਼ ਕਰਨਾ HTML ਤੋਂ ਬਚਣ ਵਾਂਗ ਹੈ ਜਦੋਂ ਕਿ ਅਸਲ ਖ਼ਤਰਾ ਹੈ SQLi.
ਅੰਤ ਵਿੱਚ, ਸਟ੍ਰਿਪਚਾਰ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਦੀ ਵਿਆਖਿਆ ਜਾਂ ਸੁਰੱਖਿਆ ਨਹੀਂ ਕਰਦਾ, ਇਹ ਸਿਰਫ਼ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਦਾ ਹੈ। ਅਤੇ ਸੰਪਾਦਨ ਸੁਰੱਖਿਆ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਅਸਲ ਸੁਰੱਖਿਆ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਟ੍ਰਕਚਰਡ, ਵੈਲੀਡੇਟਿਡ, ਅਤੇ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਪੂਰਾ ਵਿਰਾਮ।
ਫਰਕ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਲਈ, ਇੱਥੇ ਦੱਸਿਆ ਗਿਆ ਹੈ ਕਿ ਸਟ੍ਰਿਪਚਾਰ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛਾਂ ਨਾਲ ਨਾਲ-ਨਾਲ ਕਿਵੇਂ ਤੁਲਨਾ ਕਰਦਾ ਹੈ:
ਸਟ੍ਰਿਪਚਰ ਬਨਾਮ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ: ਕਿਹੜਾ ਅਸਲ ਵਿੱਚ ਤੁਹਾਡੇ ਕੋਡ ਦੀ ਰੱਖਿਆ ਕਰਦਾ ਹੈ?
| ਵਿਸ਼ੇਸ਼ਤਾ | stripchar() | ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਸਵਾਲ |
|---|---|---|
| ਸੁਰੱਖਿਆ ਦਾ ਪੱਧਰ | ਮੁੱਢਲੀ ਸਟ੍ਰਿੰਗ ਸਫਾਈ। ਏਨਕੋਡਿੰਗ ਜਾਂ ਲਾਜਿਕ ਟ੍ਰਿਕਸ ਨਾਲ ਆਸਾਨੀ ਨਾਲ ਬਾਈਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। | SQL ਇੰਜੈਕਸ਼ਨ ਦੇ ਸਾਰੇ ਰੂਪਾਂ ਦੇ ਵਿਰੁੱਧ ਮਜ਼ਬੂਤ ਸੁਰੱਖਿਆ। |
| ਸੰਦਰਭ ਜਾਗਰੂਕਤਾ | ਸੰਦਰਭ ਤੋਂ ਅੰਨ੍ਹਾ (SQL, HTML, ਸ਼ੈੱਲ, ਆਦਿ)। ਹਰ ਜਗ੍ਹਾ ਇੱਕੋ ਜਿਹਾ ਨਿਯਮ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। | ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੰਦਰਭ-ਜਾਣੂ। ਹਰੇਕ ਵਾਤਾਵਰਣ ਲਈ ਸਹੀ ਬਚਣ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। |
| ਡਿਵੈਲਪਰ ਯਤਨ | ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਤੇਜ਼ ਪਰ ਲੰਬੇ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਲਈ ਭਰੋਸੇਯੋਗ ਨਹੀਂ। | ਸਹੀ ਏਕੀਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਪਰ ਮਜ਼ਬੂਤ ਅਤੇ ਭਵਿੱਖ-ਪ੍ਰਮਾਣਿਤ। |
| ਬਾਈਪਾਸ ਵਿਰੋਧ | ਘੱਟ — ਹਮਲਾਵਰ ਵ੍ਹਾਈਟਸਪੇਸ, ਏਨਕੋਡਿੰਗ, ਜਾਂ ਤਰਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਅਨੁਕੂਲ ਬਣ ਜਾਂਦੇ ਹਨ। | ਉੱਚ — ਕੋਡ ਨੂੰ ਡੇਟਾ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ ਅਤੇ ਟੀਕੇ ਨੂੰ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਰੋਕਦਾ ਹੈ। |
| ਸੁਰੱਖਿਆ ਵਿਸ਼ਵਾਸ | ਸੁਰੱਖਿਆ ਦੀ ਗਲਤ ਭਾਵਨਾ - ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕੀਤੇ ਬਿਨਾਂ ਛੁਪਾ ਸਕਦੀ ਹੈ। | ਭਰੋਸੇਯੋਗ ਉਦਯੋਗ standard ਸੁਰੱਖਿਅਤ ਪੁੱਛਗਿੱਛ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ। |
ਹਮਲਾਵਰ ਇਨਪੁਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਬਾਈਪਾਸ ਕਰਦੇ ਹਨ
ਜਦੋਂ ਡਿਵੈਲਪਰ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਤਾਂ ਇੱਕ ਆਮ ਕਮਜ਼ੋਰ ਪ੍ਰਵਾਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਸਟ੍ਰਿਪਚਾਰ ਇਨਪੁਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਲਈ:
ਹਮਲਾਵਰਾਂ ਨੂੰ ਤੁਹਾਡੇ ਫਿਲਟਰ ਤੋੜਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ਼ ਉਹਨਾਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਜਾਓ. ਜਦੋਂ ਡਿਵੈਲਪਰ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਸਟ੍ਰਿਪਚਾਰ ਇਨਪੁਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਲਈ, ਉਹ ਅਕਸਰ ਇਹ ਮੰਨਦੇ ਹਨ ਕਿ ਕੋਟਸ ਜਾਂ ਸੈਮੀਕੋਲਨ ਵਰਗੇ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਉਣ ਨਾਲ ਟੀਕੇ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਨੂੰ ਰੋਕ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਹਾਲਾਂਕਿ, ਹਮਲਾਵਰ ਜਲਦੀ ਅਨੁਕੂਲ ਹੋ ਜਾਂਦੇ ਹਨ। ਉਹ ਅਸਪਸ਼ਟ ਪੇਲੋਡ ਜੋ regex-ਅਧਾਰਿਤ ਫਿਲਟਰਾਂ ਵਿੱਚੋਂ ਲੰਘਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਉਹਨਾਂ ਫਿਲਟਰਾਂ ਵਿੱਚ ਸੰਦਰਭ ਦੀ ਘਾਟ ਹੁੰਦੀ ਹੈ।
ਉਦਾਹਰਨ ਲਈ, ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਇਨਪੁਟ ਨੂੰ ਸੈਨੇਟਾਈਜ਼ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ:
ਭਾਵੇਂ ਉਪਭੋਗਤਾ ਕਲਾਸਿਕ ਜਮ੍ਹਾਂ ਨਹੀਂ ਕਰ ਸਕਦਾ ' OR 1=1 --, ਉਹ ਯੂਨੀਕੋਡ ਟ੍ਰਿਕਸ, ਸਟ੍ਰਿੰਗ ਕੰਕੇਟੇਨੇਸ਼ਨ, ਜਾਂ ਟੁੱਟੇ ਹੋਏ ਸਿੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ ਜੋ ਅਜੇ ਵੀ ਚੱਲਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਪੇਲੋਡ ਅਕਸਰ ਕੰਮ ਕਰਦੇ ਹਨ:
ਸੋਨੇ:
ਜੇਕਰ ਤੁਹਾਡਾ ਫੰਕਸ਼ਨ ਗੈਰ-ਸ਼ਬਦ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ ਗਲਤੀ ਨਾਲ ਇੱਕ ਵੈਧ SQL ਕਮਾਂਡ ਦਾ ਪੁਨਰ ਨਿਰਮਾਣ ਕਰੋ. ਇਸ ਤੋਂ ਵੀ ਮਾੜੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਹਮਲਾਵਰ ਮੁੱਲਾਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਏਨਕੋਡ ਕਰ ਸਕਦੇ ਹਨ ਜੋ ਤੁਹਾਡੇ ਫਿਲਟਰ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ ਪਰ ਟਾਰਗੇਟ ਸਿਸਟਮ ਦੁਆਰਾ ਡੀਕੋਡ ਹੋ ਜਾਂਦੇ ਹਨ।
SQL ਇੰਜੈਕਸ਼ਨ ਤੋਂ ਇਲਾਵਾ, ਸਟ੍ਰਿਪਚਾਰ ਹੋਰ ਸੰਦਰਭਾਂ ਵਿੱਚ ਵੀ ਅਸਫਲ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸ਼ੈੱਲ ਕਮਾਂਡਾਂ, ਫਾਈਲ ਪਾਥ, ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ। ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਇਸ ਬਾਰੇ ਕੋਈ ਜਾਗਰੂਕਤਾ ਨਹੀਂ ਹੈ ਕਿ ਇਨਪੁਟ ਕਿੱਥੇ ਵਰਤਿਆ ਜਾਵੇਗਾ, ਇਹ ਸਹੀ ਐਸਕੇਪਿੰਗ ਜਾਂ ਵੈਲੀਡੇਸ਼ਨ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦਾ।
ਫਲਸਰੂਪ, ਇਨਪੁੱਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਨਾਲ ਸਟ੍ਰਿਪਚਾਰ ਬਾਈਪਾਸ ਕਰਨਾ ਆਸਾਨ ਹੈ। ਅਸਲ ਸੁਰੱਖਿਆ ਇਸ ਤੋਂ ਆਉਂਦੀ ਹੈ ਸੰਦਰਭ-ਜਾਗਰੂਕ ਨਿਯੰਤਰਣਖਾਸ ਕਰਕੇ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਜੋ ਤਰਕ ਟੀਕੇ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰੋਕਦਾ ਹੈ।
ਤੁਹਾਨੂੰ ਇਸਦੀ ਬਜਾਏ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛਾਂ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ
ਜੇ ਤੁਸੀਂ ਟੀਕੇ ਦੇ ਹਮਲਿਆਂ ਨੂੰ ਸੱਚਮੁੱਚ ਰੋਕਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਸਟਰਿੰਗਾਂ ਨਾਲ ਪੁੱਛਗਿੱਛਾਂ ਬਣਾਉਣਾ ਬੰਦ ਕਰੋ. ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਅੰਦਰ ਆਓ। ਉਲਟ ਸਟ੍ਰਿਪਚਾਰ, ਉਹ ਫਿਲਟਰ ਨਹੀਂ ਕਰਦੇ, ਉਹ ਡੇਟਾ ਤੋਂ ਕੋਡ ਨੂੰ ਵੱਖਰਾ ਕਰੋ ਇੰਜਣ ਪੱਧਰ 'ਤੇ।
ਆਓ ਟੁੱਟੇ ਹੋਏ ਸਵਾਲ ਨੂੰ ਦੁਬਾਰਾ ਵੇਖੀਏ:
ਇਹ ਖ਼ਤਰਨਾਕ ਹੈ ਕਿਉਂਕਿ ਇਨਪੁਟ ਸਿੱਧੇ SQL ਵਿੱਚ ਇੰਜੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਅੱਖਰ ਸਟ੍ਰਿਪਿੰਗ ਦੇ ਨਾਲ ਵੀ, ਤੁਸੀਂ ਅਜੇ ਵੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਬਣਾ ਰਹੇ ਹੋ ਜਿਸਦੀ ਦੁਰਵਰਤੋਂ ਹੋ ਸਕਦੀ ਹੈ। ਇਸਦੀ ਬਜਾਏ, ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰੋ:
ਇੱਥੇ, ਡੇਟਾਬੇਸ ਡਰਾਈਵਰ ਜਾਣਦਾ ਹੈ ਕਿ userInput ਡਾਟਾ ਹੈ, ਚੱਲਣਯੋਗ ਕੋਡ ਨਹੀਂ. ਇਹ ਇਸ ਤੋਂ ਆਪਣੇ ਆਪ ਬਚ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇੰਜੈਕਸ਼ਨ ਨੂੰ ਬਲੌਕ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਇਨਪੁਟ ਵਿੱਚ ਕੋਟਸ, ਸੈਮੀਕੋਲਨ, ਜਾਂ ਹੈਕਸ-ਏਨਕੋਡ ਕੀਤੇ ਪੇਲੋਡ ਹੋਣ।
ਪਾਈਥਨ ਵਿੱਚ:
PDO ਦੇ ਨਾਲ PHP ਵਿੱਚ:
ਇਹਨਾਂ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ, ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਇਹ ਅੰਦਾਜ਼ਾ ਲਗਾਏ ਬਿਨਾਂ ਟੀਕੇ ਨੂੰ ਰੋਕੋ ਕਿ ਕਿਹੜੇ ਅੱਖਰ ਖ਼ਤਰਨਾਕ ਹੋ ਸਕਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਲੋੜ ਨਹੀਂ ਹੈ ਸਟ੍ਰਿਪਚਾਰ, ਤੁਹਾਨੂੰ ਢਾਂਚਾਗਤ, ਸੰਦਰਭ-ਜਾਗਰੂਕ ਪੁੱਛਗਿੱਛ ਨਿਰਮਾਣ ਦੀ ਲੋੜ ਹੈ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਤਕਨੀਕ ਗੁੰਝਲਦਾਰ ਪੇਲੋਡ, ਯੂਨੀਕੋਡ ਟ੍ਰਿਕਸ, ਅਤੇ ਏਨਕੋਡਿੰਗ ਬਾਈਪਾਸ ਨੂੰ ਰੋਕਦੀ ਹੈ, ਉਹੀ ਬਚਕਾਨਾ ਪੈਟਰਨ ਜੋ ਕਿ XSS ਕਮਜ਼ੋਰੀਆਂ. ਜ਼ਾਇਜੇਨੀ ਵਰਗੇ ਟੂਲ ਇਹਨਾਂ ਖਤਰਿਆਂ ਨੂੰ ਜਲਦੀ ਫੜ ਲੈਂਦੇ ਹਨ SAST ਵਿਸ਼ਲੇਸ਼ਣ.
ਸੰਖੇਪ ਵਿੱਚ, ਅਸਲ ਰੱਖਿਆ ਫਿਲਟਰਾਂ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦੇ। ਉਹ ਪ੍ਰੋਟੋਕੋਲ, ਭਰੋਸੇਯੋਗ API, ਅਤੇ ਪੂਰੇ ਸੰਦਰਭ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਫਰੇਮਵਰਕ ਜਾਂ ਡਾਇਨਾਮਿਕ ਸਰਵਿਸ ਇੰਜੈਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਸ ਗੱਲ ਤੋਂ ਜਾਣੂ ਰਹੋ ਕਿ ਇਨਪੁਟ ਤੁਹਾਡੇ ਕੋਡਬੇਸ ਰਾਹੀਂ ਕਿਵੇਂ ਪ੍ਰਸਾਰਿਤ ਹੁੰਦੇ ਹਨ। ਸੁਰੱਖਿਅਤ ਨਿਰਭਰਤਾ ਟੀਕਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਗੁੰਝਲਦਾਰ ਪ੍ਰਵਾਹ ਵੀ ਨਵੇਂ ਹਮਲੇ ਦੀਆਂ ਸਤਹਾਂ ਨੂੰ ਨਹੀਂ ਖੋਲ੍ਹਣਗੇ।
ਭਰੋਸਾ ਨਾ ਕਰੋ ਸਟ੍ਰਿਪਚਾਰ. ਅਸਲੀ ਬਚਾਅ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਜ਼ਾਇਜੇਨੀ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਭਾਵੇਂ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ, ਇਸ ਗੱਲ ਦੀ ਕੋਈ ਗਰੰਟੀ ਨਹੀਂ ਹੈ ਕਿ ਤੁਹਾਡਾ ਪੂਰਾ ਕੋਡਬੇਸ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਚੱਲੇਗਾ standard. ਪੁਰਾਣੇ ਤਰਕ, ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਸਕ੍ਰਿਪਟਾਂ, ਜਾਂ ਕਿਸੇ ਪੀਆਰ ਵਿੱਚ ਅਣਦੇਖੀਆਂ ਲਾਈਨਾਂ ਅਜੇ ਵੀ ਟੀਕੇ ਦੇ ਜੋਖਮ ਪੇਸ਼ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਇਹੀ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਜ਼ਾਇਗੇਨੀ ਮਦਦ ਕਰਦੀ ਹੈ।
ਜ਼ਾਇਜੇਨੀ ਤੁਹਾਡਾ ਸਰੋਤ ਕੋਡ ਸਕੈਨ ਕਰਦਾ ਹੈ, pull requests, ਅਤੇ ਸੀ.ਆਈ. pipelineਫੜਨ ਲਈ:
- ਪੁੱਛਗਿੱਛ ਸਤਰ ਜੋ ਕੰਕੈਟੇਨੇਸ਼ਨ ਨਾਲ SQL ਬਣਾਉਂਦੇ ਹਨ
- ਕਮਜ਼ੋਰ ਜਾਂ ਘਰੇਲੂ ਫਿਲਟਰ ਜਿਵੇਂ ਕਿ ਸਟ੍ਰਿਪਚਾਰ
- ਸ਼ੱਕੀ ਤਰਕ ਜੋ ਜਾਣੇ-ਪਛਾਣੇ ਅਸਪਸ਼ਟ ਪੇਲੋਡਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ
ਤੁਹਾਨੂੰ ਹਰ ਲਾਈਨ ਵਿੱਚੋਂ ਕੰਘੀ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। Xygeni ਅਸੁਰੱਖਿਅਤ ਪੈਟਰਨਾਂ ਨੂੰ ਜਲਦੀ ਹੀ ਫਲੈਗ ਕਰਦਾ ਹੈ, ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਆਟੋਫਿਕਸ ਜਿੱਥੇ ਸੰਭਵ ਹੋਵੇ, ਅਤੇ ਅਨੁਕੂਲਿਤ ਕਰਨ ਯੋਗ ਨਾਲ ਜੋਖਮ ਭਰੇ ਵਿਲੀਨਤਾਵਾਂ ਨੂੰ ਰੋਕ ਸਕਦਾ ਹੈ Guardrails.
ਸੰਖੇਪ ਵਿੱਚ, Xygeni ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛਾਂ ਸਿਰਫ਼ ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਹੀ ਨਹੀਂ ਹਨ, ਸਗੋਂ ਉਹਨਾਂ ਨੂੰ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਹੁਣ ਕੋਈ ਅੰਦਾਜ਼ਾ ਨਹੀਂ। ਕੋਈ ਖੁੰਝੇ ਹੋਏ ਫਿਲਟਰ ਨਹੀਂ। ਬਸ ਅਸਲੀ ਸੁਰੱਖਿਆ।f
ਕੀ ਤੁਸੀਂ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ Xygeni ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਅਸੁਰੱਖਿਅਤ ਸਵਾਲਾਂ ਨੂੰ ਕਿਵੇਂ ਲੱਭਦਾ ਹੈ?
ਮੁੱਖ ਨੁਕਤੇ: ਯਾਦ ਰੱਖਣ ਵਾਲੀਆਂ ਗੱਲਾਂ ਸਟ੍ਰਿਪਚਾਰ ਅਤੇ ਟੀਕੇ ਦੇ ਜੋਖਮ
- ਸਟ੍ਰਿਪਚਾਰ ਇਹ ਕੋਈ ਸੁਰੱਖਿਆ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ — ਇਹ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਜੋਖਮ ਨੂੰ ਨਹੀਂ।
- ਇਨਪੁਟ ਸੈਨੀਟਾਈਜ਼ੇਸ਼ਨ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਸਟ੍ਰਿੰਗ ਕੰਕੇਟੇਨੇਸ਼ਨ ਨਾਲ ਪੁੱਛਗਿੱਛਾਂ ਬਣਾ ਰਹੇ ਹੋ।
- ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਪੁੱਛਗਿੱਛ ਸਹੀ ਬਚਾਅ ਹਨ, ਅਤੇ ਹਰ ਆਧੁਨਿਕ ਭਾਸ਼ਾ ਜਾਂ ਢਾਂਚਾ ਉਹਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।
- ਅਸਪਸ਼ਟ ਪੇਲੋਡ ਫਿਲਟਰਾਂ ਤੋਂ ਲੰਘ ਸਕਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਜੇਕਰ ਏਨਕੋਡਿੰਗ ਟ੍ਰਿਕਸ ਸ਼ਾਮਲ ਹਨ।
- ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ (SAST) ਔਜ਼ਾਰ ਉਹ ਫੜਦੇ ਹਨ ਜੋ ਮਨੁੱਖ ਗੁਆ ਦਿੰਦੇ ਹਨ, ਜਿਸ ਵਿੱਚ ਪੁਰਾਣੇ ਕੋਡ ਵਿੱਚ ਲੁਕੇ ਹੋਏ ਅਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਸ਼ਾਮਲ ਹਨ।
- Xygeni ਖੋਜ, ਤਰਜੀਹ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਉਪਚਾਰ ਨੂੰ ਸਵੈਚਾਲਿਤ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਹਾਡੀ ਟੀਮ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਪਿੱਛਾ ਕਰਨ ਦੀ ਬਜਾਏ, ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਿਖਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰ ਸਕੇ।
ਸਿੱਟਾ: ਫਿਲਟਰਾਂ 'ਤੇ ਭਰੋਸਾ ਨਾ ਕਰੋ। ਡਿਜ਼ਾਈਨ ਦੁਆਰਾ ਸੁਰੱਖਿਅਤ।
ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਨਾ ਸਟ੍ਰਿਪਚਾਰ ਇਹ ਇੱਕ ਤੇਜ਼ ਹੱਲ ਵਾਂਗ ਜਾਪ ਸਕਦਾ ਹੈ, ਪਰ ਉਹ ਸੁਰੱਖਿਆ ਦੀ ਇੱਕ ਝੂਠੀ ਭਾਵਨਾ ਪੈਦਾ ਕਰਦੇ ਹਨ। ਹਮਲਾਵਰ ਸਟ੍ਰਿੰਗ ਫਿਲਟਰਾਂ ਨਾਲੋਂ ਤੇਜ਼ੀ ਨਾਲ ਵਿਕਸਤ ਹੁੰਦੇ ਹਨ। ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਨੂੰ ਰੋਕਣ ਦਾ ਇੱਕੋ ਇੱਕ ਭਰੋਸੇਯੋਗ ਤਰੀਕਾ ਹੈ ਡਿਜ਼ਾਈਨ ਦੁਆਰਾ ਸੁਰੱਖਿਅਤ ਕੋਡ ਲਿਖਣਾ, ਅਤੇ ਉਸ ਡਿਜ਼ਾਈਨ ਨੂੰ ਹਰ ਜਗ੍ਹਾ ਲਾਗੂ ਕਰਨਾ।
Xygeni ਵਰਗੇ ਟੂਲ ਤੁਹਾਨੂੰ ਇਹ ਆਪਣੇ ਆਪ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। ਤੋਂ pull request ਨੂੰ pipeline, ਉਹ ਉਹ ਫੜ ਲੈਂਦੇ ਹਨ ਜੋ ਤੁਹਾਡੇ ਫਿਲਟਰ ਨਹੀਂ ਫੜਦੇ, ਅਤੇ ਉਤਪਾਦਨ ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਠੀਕ ਕਰ ਦਿੰਦੇ ਹਨ।
