🥇ਪਾਗਲ ਹੋਏ ਬਿਨਾਂ ਚੈੱਕਮਾਰਕਸ ਲਈ ਨਿਯਮ ਕਿਵੇਂ ਲਿਖਣੇ ਹਨ

ਹੇ ਹਬਰ!

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

ਅਸੀਂ ਅਕਸਰ ਚੈੱਕਮਾਰਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ - ਇੱਕ ਬਹੁਤ ਹੀ ਦਿਲਚਸਪ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕੋਡ ਵਿਸ਼ਲੇਸ਼ਕ। ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਇਸਦੇ ਲਈ ਵਿਸ਼ਲੇਸ਼ਣ ਨਿਯਮਾਂ ਨੂੰ ਲਿਖਣ ਦੇ ਆਪਣੇ ਅਨੁਭਵ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ।

ਇੰਦਰਾਜ਼

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਮੈਂ ਚੈੱਕਮਾਰਕਸ ਲਈ ਪ੍ਰਸ਼ਨ ਲਿਖਣ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਰੂਸੀ ਵਿੱਚ ਕੁਝ ਲੇਖਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਨਾ ਚਾਹਾਂਗਾ। ਇਹ ਸਿਰਲੇਖ ਹੇਠ 2019 ਦੇ ਅੰਤ ਵਿੱਚ ਹੈਬਰੇ ਉੱਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ: "ਹੈਲੋ, ਚੈੱਕਮਾਰਕਸ!" ਚੈੱਕਮਾਰਕਸ SAST ਪੁੱਛਗਿੱਛ ਕਿਵੇਂ ਲਿਖਣੀ ਹੈ ਅਤੇ ਸ਼ਾਨਦਾਰ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਹੈ.

ਇਹ ਵਿਸਤਾਰ ਵਿੱਚ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੁਝ ਟੈਸਟ ਐਪਲੀਕੇਸ਼ਨ ਲਈ CxQL (ਚੈੱਕਮਾਰਕਸ ਕਿਊਰੀ ਲੈਂਗੂਏਜ) ਵਿੱਚ ਪਹਿਲੀਆਂ ਸਵਾਲਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਨਿਯਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਦੇ ਮੂਲ ਸਿਧਾਂਤ ਦਿਖਾਉਂਦਾ ਹੈ।

ਮੈਂ ਇਸ ਵਿੱਚ ਵਰਣਨ ਕੀਤੇ ਗਏ ਸ਼ਬਦਾਂ ਨੂੰ ਨਹੀਂ ਦੁਹਰਾਵਾਂਗਾ, ਹਾਲਾਂਕਿ ਕੁਝ ਇੰਟਰਸੈਕਸ਼ਨ ਅਜੇ ਵੀ ਮੌਜੂਦ ਹੋਣਗੇ. ਮੇਰੇ ਲੇਖ ਵਿੱਚ ਮੈਂ "ਪਕਵਾਨਾਂ ਦਾ ਸੰਗ੍ਰਹਿ" ਦੀ ਇੱਕ ਕਿਸਮ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗਾ, ਖਾਸ ਸਮੱਸਿਆਵਾਂ ਦੇ ਹੱਲਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਜੋ ਮੈਂ ਚੈੱਕਮਾਰਕਸ ਦੇ ਨਾਲ ਮੇਰੇ ਕੰਮ ਦੌਰਾਨ ਆਈਆਂ ਹਨ। ਮੈਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ 'ਤੇ ਆਪਣੇ ਦਿਮਾਗ ਨੂੰ ਰੈਕ ਕਰਨਾ ਪਿਆ. ਕਈ ਵਾਰ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਲੋੜੀਂਦੀ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੁੰਦੀ ਸੀ, ਅਤੇ ਕਈ ਵਾਰ ਇਹ ਸਮਝਣਾ ਵੀ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਸੀ ਕਿ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੇਰਾ ਤਜਰਬਾ ਅਤੇ ਨੀਂਦ ਦੀਆਂ ਰਾਤਾਂ ਵਿਅਰਥ ਨਹੀਂ ਜਾਣਗੀਆਂ, ਅਤੇ ਇਹ "ਕਸਟਮ ਪੁੱਛਗਿੱਛਾਂ ਦੇ ਪਕਵਾਨਾਂ ਦਾ ਸੰਗ੍ਰਹਿ" ਤੁਹਾਨੂੰ ਕੁਝ ਘੰਟਿਆਂ ਜਾਂ ਕੁਝ ਨਰਵ ਸੈੱਲਾਂ ਦੀ ਬਚਤ ਕਰੇਗਾ। ਇਸ ਲਈ, ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ!

ਨਿਯਮਾਂ ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ

ਪਹਿਲਾਂ, ਆਓ ਅੱਗੇ ਕੀ ਹੋਵੇਗਾ, ਇਸ ਦੀ ਬਿਹਤਰ ਸਮਝ ਲਈ, ਕੁਝ ਬੁਨਿਆਦੀ ਧਾਰਨਾਵਾਂ ਅਤੇ ਨਿਯਮਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਵੇਖੀਏ। ਅਤੇ ਇਹ ਵੀ ਕਿਉਂਕਿ ਦਸਤਾਵੇਜ਼ ਇਸ ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਕਹਿੰਦੇ ਹਨ ਜਾਂ ਢਾਂਚੇ ਵਿੱਚ ਬਹੁਤ ਫੈਲਿਆ ਹੋਇਆ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ।

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

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

CxAudit ਇੰਟਰਫੇਸ
ਚੈੱਕਮਾਰਕਸ ਵਿੱਚ ਨਿਯਮਾਂ ਨੂੰ ਭਾਸ਼ਾ ਦੁਆਰਾ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ, ਭਾਵ, ਹਰੇਕ ਭਾਸ਼ਾ ਦੇ ਆਪਣੇ ਸਵਾਲਾਂ ਦਾ ਸੈੱਟ ਹੁੰਦਾ ਹੈ। ਕੁਝ ਆਮ ਨਿਯਮ ਵੀ ਹਨ ਜੋ ਭਾਸ਼ਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਲਾਗੂ ਹੁੰਦੇ ਹਨ, ਇਹ ਅਖੌਤੀ ਬੁਨਿਆਦੀ ਸਵਾਲ ਹਨ। ਜ਼ਿਆਦਾਤਰ ਹਿੱਸੇ ਲਈ, ਬੁਨਿਆਦੀ ਸਵਾਲਾਂ ਵਿੱਚ ਅਜਿਹੀ ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਜੋ ਦੂਜੇ ਨਿਯਮ ਵਰਤਦੇ ਹਨ।

ਭਾਸ਼ਾ ਦੁਆਰਾ ਨਿਯਮਾਂ ਨੂੰ ਵੰਡਣਾ
ਨਿਯਮ "ਐਗਜ਼ੀਕਿਊਟੇਬਲ" ਅਤੇ "ਨਾਨ-ਐਗਜ਼ੀਕਿਊਟੇਬਲ" (ਐਗਜ਼ੀਕਿਊਟਡ ਅਤੇ ਨਾਟ ਐਗਜ਼ੀਕਿਊਟਿਡ) ਹਨ। ਬਿਲਕੁਲ ਸਹੀ ਨਾਮ ਨਹੀਂ, ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਪਰ ਇਹ ਉਹੀ ਹੈ ਜੋ ਇਹ ਹੈ। ਤਲ ਲਾਈਨ ਇਹ ਹੈ ਕਿ "ਐਗਜ਼ੀਕਿਊਟੇਬਲ" ਨਿਯਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਨਤੀਜਾ UI ਵਿੱਚ ਸਕੈਨ ਨਤੀਜਿਆਂ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ, ਅਤੇ "ਨਾਨ-ਐਗਜ਼ੀਕਿਊਟੇਬਲ" ਨਿਯਮਾਂ ਦੀ ਲੋੜ ਸਿਰਫ਼ ਉਹਨਾਂ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਹੋਰ ਬੇਨਤੀਆਂ ਵਿੱਚ ਵਰਤਣ ਲਈ ਹੈ (ਸਾਰ ਰੂਪ ਵਿੱਚ, ਸਿਰਫ਼ ਇੱਕ ਫੰਕਸ਼ਨ)।

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

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

ਪੂਰੇ ਸਿਸਟਮ ਲਈ - ਕਿਸੇ ਵੀ ਪ੍ਰੋਜੈਕਟ ਦੀ ਸਕੈਨਿੰਗ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ
ਟੀਮ ਪੱਧਰ 'ਤੇ (ਟੀਮ) - ਸਿਰਫ ਚੁਣੀ ਗਈ ਟੀਮ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਵੇਗਾ।
ਪ੍ਰੋਜੈਕਟ ਪੱਧਰ 'ਤੇ - ਇੱਕ ਖਾਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ

ਉਹ ਪੱਧਰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਜਿਸ 'ਤੇ ਨਿਯਮ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ

ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ "ਡਕਸ਼ਨਰੀ"

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

ਸੂਚੀਆਂ ਦੇ ਨਾਲ ਸੰਚਾਲਨ

- вычитание одного из другого (list2 - list1)
* пересечение списков (list1 * list2)
+ сложение списков (list1 + list2)

& (логическое И) - объединяет списки по совпадению (list1 & list2), аналогично пересечению (list1 * list2)
| (логическое ИЛИ) - объединяет списки по широкому поиску (list1 | list2)

Со списками не работает:  ^  &&  ||  %  /

ਸਾਰੀਆਂ ਆਈਟਮਾਂ ਲੱਭੀਆਂ

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

// Такой запрос выдаст все элементы
result = All;

// Такой запрос выдаст все элементы, в имени которых присутствует “searchMe“
result = All.FindByName("searchMe");

ਪਰ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਿਸੇ ਹੋਰ ਭਾਸ਼ਾ ਵਿੱਚ ਖੋਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ ਸਕੈਨ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤੀ ਗਈ ਸੀ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ Android ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ groovy), ਤੁਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਰਾਹੀਂ ਸਾਡੇ ਆਬਜੈਕਟ ਸਪੇਸ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹੋ:

result = AllMembers.All.FindByName("searchMe");

ਵਹਾਅ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਫੰਕਸ਼ਨ

ਇਹ ਫੰਕਸ਼ਨ ਬਹੁਤ ਸਾਰੇ ਨਿਯਮਾਂ ਵਿੱਚ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਇੱਥੇ ਉਹਨਾਂ ਦੇ ਅਰਥਾਂ ਦੀ ਇੱਕ ਛੋਟੀ ਚੀਟ ਸ਼ੀਟ ਹੈ:

// Какие данные second влияют на first.
// Другими словами - ТО (second) что влияет на  МЕНЯ (first).
result = first.DataInfluencedBy(second);

// Какие данные first влияют на second.
// Другими словами - Я (first) влияю на ТО (second).
result = first.DataInfluencingOn(second);

ਫਾਈਲ ਦਾ ਨਾਮ/ਪਾਥ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਇੱਥੇ ਕਈ ਗੁਣ ਹਨ ਜੋ ਇੱਕ ਪੁੱਛਗਿੱਛ ਦੇ ਨਤੀਜਿਆਂ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ (ਉਸ ਫਾਈਲ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਐਂਟਰੀ ਪਾਈ ਗਈ ਸੀ, ਸਤਰ, ਆਦਿ), ਪਰ ਦਸਤਾਵੇਜ਼ ਇਹ ਨਹੀਂ ਦੱਸਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ ਅਤੇ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ। ਇਸ ਲਈ, ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਲਾਈਨਪ੍ਰਾਗਮਾ ਸੰਪੱਤੀ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਸਾਨੂੰ ਲੋੜੀਂਦੀਆਂ ਵਸਤੂਆਂ ਇਸ ਦੇ ਅੰਦਰ ਸਥਿਤ ਹੋਣਗੀਆਂ:

// Для примера найдем все методы
CxList methods = Find_Methods();

// В методах найдем по имени метод scope
CxList scope = methods.FindByName("scope");

// Таким образом можо получить путь к файлу
string current_filename = scope.GetFirstGraph().LinePragma.FileName;

// А вот таким - строку, где нашлось срабатывание
int current_line = scope.GetFirstGraph().LinePragma.Line;

// Эти параметры можно использовать по разному
// Например получить все объекты в файле
CxList inFile = All.FindByFileName(current_filename);

// Или найти что происходит в конкретной строке
CxList inLine = inFile.FindByPosition(current_line);

ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ FileName ਅਸਲ ਵਿੱਚ ਫਾਈਲ ਦਾ ਮਾਰਗ ਰੱਖਦਾ ਹੈ, ਕਿਉਂਕਿ ਅਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ GetFirstGraph.

ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨਤੀਜਾ

CxQL ਦੇ ਅੰਦਰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵੇਰੀਏਬਲ ਹੈ result, ਜੋ ਤੁਹਾਡੇ ਲਿਖਤੀ ਨਿਯਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਤੁਰੰਤ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਵਿਚਕਾਰਲੇ ਨਤੀਜੇ ਲਿਖ ਸਕਦੇ ਹੋ, ਉਹਨਾਂ ਨੂੰ ਬਦਲਦੇ ਅਤੇ ਸੁਧਾਰਦੇ ਹੋਏ ਜਿਵੇਂ ਤੁਸੀਂ ਕੰਮ ਕਰਦੇ ਹੋ। ਪਰ, ਜੇਕਰ ਨਿਯਮ ਦੇ ਅੰਦਰ ਇਸ ਵੇਰੀਏਬਲ ਜਾਂ ਫੰਕਸ਼ਨ ਲਈ ਕੋਈ ਅਸਾਈਨਮੈਂਟ ਨਹੀਂ ਹੈ return- ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨਤੀਜਾ ਹਮੇਸ਼ਾ ਜ਼ੀਰੋ ਹੋਵੇਗਾ।

ਹੇਠ ਦਿੱਤੀ ਪੁੱਛਗਿੱਛ ਅਮਲ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਸਾਨੂੰ ਕੁਝ ਵੀ ਵਾਪਸ ਨਹੀਂ ਕਰੇਗੀ ਅਤੇ ਹਮੇਸ਼ਾ ਖਾਲੀ ਰਹੇਗੀ:

// Находим элементы foo
CxList libraries = All.FindByName("foo");

ਪਰ, ਜਾਦੂ ਵੇਰੀਏਬਲ ਨਤੀਜੇ ਨੂੰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨਤੀਜਾ ਨਿਰਧਾਰਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਇਹ ਕਾਲ ਸਾਨੂੰ ਕੀ ਵਾਪਸ ਕਰਦੀ ਹੈ:

// Находим элементы foo
CxList libraries = All.FindByName("foo");

// Выводим, как результат выполнения правила
result = libraries

// Или еще короче
result = All.FindByName("foo");

ਹੋਰ ਨਿਯਮਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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

// Получаем результат выполнения другого правила
CxList methods = Find_Methods();

// Ищем внутри метод foo. 
// Второй параметр false означает, что ищем без чувствительности к регистру
result = methods.FindByShortName("foo", false);

ਇਹ ਪਹੁੰਚ ਤੁਹਾਨੂੰ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਅਤੇ ਨਿਯਮ ਲਾਗੂ ਕਰਨ ਦੇ ਸਮੇਂ ਨੂੰ ਮਹੱਤਵਪੂਰਣ ਰੂਪ ਵਿੱਚ ਘਟਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।

ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ

ਲਾਗਿੰਗ

ਟੂਲ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਕਈ ਵਾਰ ਲੋੜੀਂਦੀ ਪੁੱਛਗਿੱਛ ਨੂੰ ਤੁਰੰਤ ਲਿਖਣਾ ਸੰਭਵ ਨਹੀਂ ਹੁੰਦਾ ਅਤੇ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋਏ ਪ੍ਰਯੋਗ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਅਜਿਹੇ ਕੇਸ ਲਈ, ਟੂਲ ਲੌਗਿੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ:

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Формируем строку и отправляем в лог
cxLog.WriteDebugMessage (“number of DOM elements =” + All.Count);

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

ਇੱਕ ਹੋਰ ਸੁਵਿਧਾਜਨਕ ਢੰਗ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਹੈ return ਲੋੜੀਂਦੇ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਲ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਨਿਯਮ ਦਾ ਅਮਲ ਖਤਮ ਹੋ ਜਾਵੇਗਾ ਅਤੇ ਅਸੀਂ ਇਹ ਵੇਖਣ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ ਕਿ ਅਸੀਂ ਜੋ ਲਿਖਿਆ ਉਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕੀ ਹੋਇਆ:

// Находим что-то
CxList toLog = All.FindByShortName("log");

// Выводим результат выполнения
return toLog

//Все, что написано дальше не будет выполнено
result = All.DataInfluencedBy(toLog)

ਲਾਗਇਨ ਸਮੱਸਿਆ

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

8.6 ਤੋਂ ਪਹਿਲਾਂ ਚੈੱਕਮਾਰਕਸ ਲਈ:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE [ClientType] = 6;

8.6 ਤੋਂ ਬਾਅਦ ਚੈੱਕਮਾਰਕਸ ਲਈ:

// Проверяем, что есть залогиненые пользователи, выполнив запрос в БД
SELECT COUNT(*) FROM LoggedinUser WHERE (ClientType = 'Audit');
 
// Если что-то есть, а на самом деле даже если и нет, попробовать выполнить запрос
DELETE FROM [CxDB].[dbo].LoggedinUser WHERE (ClientType = 'Audit');

ਲਿਖਣ ਦੇ ਨਿਯਮ

ਹੁਣ ਅਸੀਂ ਸਭ ਤੋਂ ਦਿਲਚਸਪ ਹਿੱਸੇ ਤੇ ਆਉਂਦੇ ਹਾਂ. ਜਦੋਂ ਤੁਸੀਂ CxQL ਵਿੱਚ ਨਿਯਮ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਅਕਸਰ ਇੰਨੇ ਜ਼ਿਆਦਾ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਕਮੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਜਿੰਨੀ ਕਿ ਕੁਝ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀਆਂ ਕੁਝ ਜੀਵਤ ਉਦਾਹਰਣਾਂ ਅਤੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਆਮ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ।

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

ਇਸ ਲਈ, ਇੱਥੇ ਉਹ ਸਮੱਸਿਆਵਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਸਾਨੂੰ ਅਕਸਰ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ:

ਚੁਣੌਤੀ: ਨਿਯਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਨਤੀਜਿਆਂ ਵਿੱਚ ਕਈ ਪ੍ਰਵਾਹ ਹਨ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੂਜੇ ਦਾ ਆਲ੍ਹਣਾ ਹੈ, ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਛੱਡ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ।

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

// Оставить только длинные Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow);

// Оставить только короткие Flow
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceBigFlow);

ਚੁਣੌਤੀ: ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਦੀ ਸੂਚੀ ਦਾ ਵਿਸਤਾਰ ਕਰੋ ਜਿਸ 'ਤੇ ਟੂਲ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦਾ ਹੈ

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

ਜਨਰਲ_ਪਰਾਈਵੇਸੀ_ਉਲੰਘਣ_ਸੂਚੀ

ਆਓ ਕਈ ਵੇਰੀਏਬਲ ਜੋੜੀਏ ਜੋ ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸੰਵੇਦਨਸ਼ੀਲ ਜਾਣਕਾਰੀ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ:

// Получаем результат выполнения базового правила
result = base.General_privacy_violation_list();

// Ищем элементы, которые попадают под простые регулярные выражения. Можно дополнить характерными для вас паттернами.
CxList personalList = All.FindByShortNames(new List<string> {
	"*securityToken*", "*sessionId*"}, false);

// Добавляем к конечному результату
result.Add(personalList);

ਚੁਣੌਤੀ: ਪਾਸਵਰਡਾਂ ਨਾਲ ਵੇਰੀਏਬਲਾਂ ਦੀ ਸੂਚੀ ਦਾ ਵਿਸਤਾਰ ਕਰੋ

ਹੱਲ: ਮੈਂ ਕੋਡ ਵਿੱਚ ਪਾਸਵਰਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਅਤੇ ਇਸ ਵਿੱਚ ਵੇਰੀਏਬਲ ਨਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਜੋੜਨ ਲਈ ਮੁਢਲੇ ਨਿਯਮ ਵੱਲ ਤੁਰੰਤ ਧਿਆਨ ਦੇਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਾਂਗਾ ਜੋ ਤੁਹਾਡੀ ਕੰਪਨੀ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਪਾਸਵਰਡ_ਪ੍ਰਾਈਵੇਸੀ_ਉਲੰਘਣ_ਸੂਚੀ

CxList allStrings = All.FindByType("String"); 
allStrings.Add(All.FindByType(typeof(StringLiteral))); 
allStrings.Add(Find_UnknownReference());
allStrings.Add(All.FindByType(typeof (Declarator)));
allStrings.Add(All.FindByType(typeof (MemberAccess)));
allStrings.Add(All.FindByType(typeof(EnumMemberDecl))); 
allStrings.Add(Find_Methods().FindByShortName("get*"));

// Дополняем дефолтный список переменных
List < string > pswdIncludeList = new List<string>{"*password*", "*psw", "psw*", "pwd*", "*pwd", "*authKey*", "pass*", "cipher*", "*cipher", "pass", "adgangskode", "benutzerkennwort", "chiffre", "clave", "codewort", "contrasena", "contrasenya", "geheimcode", "geslo", "heslo", "jelszo", "kennwort", "losenord", "losung", "losungswort", "lozinka", "modpas", "motdepasse", "parol", "parola", "parole", "pasahitza", "pasfhocal", "passe", "passord", "passwort", "pasvorto", "paswoord", "salasana", "schluessel", "schluesselwort", "senha", "sifre", "wachtwoord", "wagwoord", "watchword", "zugangswort", "PAROLACHIAVE", "PAROLA CHIAVE", "PAROLECHIAVI", "PAROLE CHIAVI", "paroladordine", "verschluesselt", "sisma",
                "pincode",
								"pin"};
								
List < string > pswdExcludeList = new List<string>{"*pass", "*passable*", "*passage*", "*passenger*", "*passer*", "*passing*", "*passion*", "*passive*", "*passover*", "*passport*", "*passed*", "*compass*", "*bypass*", "pass-through", "passthru", "passthrough", "passbytes", "passcount", "passratio"};

CxList tempResult = allStrings.FindByShortNames(pswdIncludeList, false);
CxList toRemove = tempResult.FindByShortNames(pswdExcludeList, false);
tempResult -= toRemove;
tempResult.Add(allStrings.FindByShortName("pass", false));

foreach (CxList r in tempResult)
{
	CSharpGraph g = r.data.GetByIndex(0) as CSharpGraph;
	if(g != null && g.ShortName != null && g.ShortName.Length < 50)
	{
		result.Add(r);
	}
}

ਚੁਣੌਤੀ: ਵਰਤੇ ਗਏ ਫਰੇਮਵਰਕ ਸ਼ਾਮਲ ਕਰੋ ਜੋ ਚੈੱਕਮਾਰਕਸ ਦੁਆਰਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ

ਹੱਲ: ਚੈੱਕਮਾਰਕਸ ਵਿੱਚ ਸਾਰੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਭਾਸ਼ਾ ਦੁਆਰਾ ਵੰਡੀਆਂ ਗਈਆਂ ਹਨ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਹਰੇਕ ਭਾਸ਼ਾ ਲਈ ਨਿਯਮ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਹੇਠਾਂ ਅਜਿਹੇ ਨਿਯਮਾਂ ਦੀਆਂ ਕੁਝ ਉਦਾਹਰਣਾਂ ਹਨ।

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

ਟੈਸਟ ਕੋਡ ਉਦਾਹਰਨ ਜੋ ਲੌਗਿੰਗ ਲਈ ਟਿੰਬਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ:

package com.death.timberdemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import timber.log.Timber;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Timber.e("Error Message");
        Timber.d("Debug Message");

        Timber.tag("Some Different tag").e("And error message");
    }
}

ਅਤੇ ਇੱਥੇ ਚੈੱਕਮਾਰਕਸ ਲਈ ਇੱਕ ਬੇਨਤੀ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਡੇਟਾ ਲਈ ਇੱਕ ਐਗਜ਼ਿਟ ਪੁਆਇੰਟ ਵਜੋਂ ਟਿੰਬਰ ਵਿਧੀਆਂ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਪਰਿਭਾਸ਼ਾ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗੀ:

ਐਂਡਰਾਇਡ ਆਉਟਪੁੱਟ ਲੱਭੋ

// Получаем результат выполнения базового правила
result = base.Find_Android_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
CxList timber = All.FindByExactMemberAccess("Timber.*") +
    All.FindByShortName("Timber").GetMembersOfTarget();

// Добавляем к конечному результату
result.Add(timber);

ਅਤੇ ਤੁਸੀਂ ਗੁਆਂਢੀ ਨਿਯਮ ਵਿੱਚ ਵੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਐਂਡਰੌਇਡ ਵਿੱਚ ਲੌਗਿੰਗ ਨਾਲ ਸਬੰਧਤ ਹੈ:

FindAndroidLog_Outputs

// Получаем результат выполнения базового правила
result = base.Find_Android_Log_Outputs();

// Дополняем вызовами, которые приходят из библиотеки Timber
result.Add(
  All.FindByExactMemberAccess("Timber.*") +
  All.FindByShortName("Timber").GetMembersOfTarget()
);

ਨਾਲ ਹੀ, ਜੇਕਰ ਐਂਡਰੌਇਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਵਰਕਮੈਨੇਜਰ ਅਸਿੰਕਰੋਨਸ ਕੰਮ ਲਈ, ਕਾਰਜ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਵਿਧੀ ਜੋੜ ਕੇ ਇਸ ਬਾਰੇ ਚੈੱਕਮਾਰਕਸ ਨੂੰ ਸੂਚਿਤ ਕਰਨਾ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੈ। getInputData:

FindAndroidRead

// Получаем результат выполнения базового правила
result = base.Find_Android_Read();

// Дополняем вызовом функции getInputData, которая используется в WorkManager
CxList getInputData = All.FindByShortName("getInputData");

// Добавляем к конечному результату
result.Add(getInputData.GetMembersOfTarget());

ਚੁਣੌਤੀ: ਆਈਓਐਸ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਪਲਿਸਟ ਵਿੱਚ ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਦੀ ਖੋਜ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

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

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

ਅਜਿਹੀ ਫਾਈਲ ਦੀ ਇੱਕ ਉਦਾਹਰਣ, ਜਿਸ ਵਿੱਚ ਬੈਕਐਂਡ ਸੇਵਾ ਨਾਲ ਸੰਚਾਰ ਲਈ ਇੱਕ ਟੋਕਨ ਹੈ:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>DeviceDictionary</key>
	<dict>
		<key>phone</key>
		<string>iPhone 6s</string>
	</dict>
	<key>privatekey</key>
	<string>MIICXAIBAAKBgQCqGKukO1De7zhZj6+</string>
</dict>
</plist>

ਅਤੇ ਚੈੱਕਮਾਰਕਸ ਲਈ ਇੱਕ ਨਿਯਮ, ਜਿਸ ਵਿੱਚ ਕਈ ਸੂਖਮਤਾਵਾਂ ਹਨ ਜੋ ਲਿਖਣ ਵੇਲੇ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ:

// Используем результат выполнения правила по поиску файлов plist, чтобы уменьшить время работы правила и 
CxList plist = Find_Plist_Elements();

// Инициализируем новую переменную
CxList dictionarySettings = All.NewCxList();

// Теперь добавим поиск всех интересующих нас значений. В дальнейшем можно расширять этот список.
// Для поиска значений, как ни странно, используется FindByMemberAccess - поиск обращений к методам. Второй параметр внутри функции, false, означает, что поиск нечувствителен к регистру
dictionarySettings.Add(plist.FindByMemberAccess("privatekey", false));
dictionarySettings.Add(plist.FindByMemberAccess("privatetoken", false));

// Для корректного поиска из-за особенностей структуры plist - нужно искать по типу "If statement"
CxList ifStatements = plist.FindByType(typeof(IfStmt));

// Добавляем в результат, перед этим получив родительский узел - для правильного отображения
result = dictionarySettings.FindByFathers(ifStatements);

ਚੁਣੌਤੀ: XML ਵਿੱਚ ਜਾਣਕਾਰੀ ਲੱਭਣਾ

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

ਇੱਥੇ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਇੱਕ ਗਲਤ ਉਦਾਹਰਨ ਹੈ:

// Код работать не будет
result = All.FindXmlAttributesByNameAndValue("*.app", 8, “id”, "error- section", false, true);

ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਸਾਨੂੰ ਇੱਕ ਗਲਤੀ ਪ੍ਰਾਪਤ ਹੋਵੇਗੀ All ਅਜਿਹਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ... ਅਤੇ ਇਹ ਸੱਚ ਹੈ, ਕਿਉਂਕਿ XML ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼, ਵੱਖਰੀ ਆਬਜੈਕਟ ਸਪੇਸ ਹੈ - cxXPath. ਐਂਡਰੌਇਡ ਵਿੱਚ ਇੱਕ ਸੈਟਿੰਗ ਲੱਭਣ ਲਈ ਸਹੀ ਪੁੱਛਗਿੱਛ ਇਹ ਹੈ ਜੋ HTTP ਟ੍ਰੈਫਿਕ ਦੀ ਵਰਤੋਂ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ:

// Правильный вариант с использованием cxXPath
result = cxXPath.FindXmlAttributesByNameAndValue("*.xml", 8, "cleartextTrafficPermitted", "true", false, true);

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

"*.xml"- ਖੋਜੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਫਾਈਲਾਂ ਦਾ ਮਾਸਕ
8 — ਉਸ ਭਾਸ਼ਾ ਦੀ ਆਈਡੀ ਜਿਸ ਲਈ ਨਿਯਮ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ
"cleartextTrafficPermitted"- xml ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤਾ ਦਾ ਨਾਮ
"true" — ਇਸ ਗੁਣ ਦਾ ਮੁੱਲ
false - ਖੋਜ ਕਰਦੇ ਸਮੇਂ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ
true — ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਖੋਜ ਕੇਸ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਕੇ ਕੀਤੀ ਜਾਵੇਗੀ, ਯਾਨੀ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਇੱਕ ਨਿਯਮ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਜੋ ਗਲਤ ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ, ਸੁਰੱਖਿਆ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਐਂਡਰੌਇਡ ਵਿੱਚ ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨ ਸੈਟਿੰਗਾਂ ਜੋ HTTP ਪ੍ਰੋਟੋਕੋਲ ਰਾਹੀਂ ਸਰਵਰ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ। ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਵਾਲੀ ਸੈਟਿੰਗ ਦੀ ਉਦਾਹਰਨ cleartextTrafficPermitted ਅਰਥ ਦੇ ਨਾਲ true:

<network-security-config>
    <domain-config>
        <domain includeSubdomains="true">example.com</domain>
        <trust-anchors>
            <certificates src="@raw/my_ca"/>
        </trust-anchors>
        <domain-config cleartextTrafficPermitted="true">
            <domain includeSubdomains="true">secure.example.com</domain>
        </domain-config>
    </domain-config>
</network-security-config>

ਚੁਣੌਤੀ: ਫਾਈਲ ਨਾਮ/ਪਾਥ ਦੁਆਰਾ ਨਤੀਜਿਆਂ ਨੂੰ ਸੀਮਿਤ ਕਰੋ

ਹੱਲ: ਐਂਡਰੌਇਡ ਲਈ ਇੱਕ ਮੋਬਾਈਲ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਵਿਕਾਸ ਨਾਲ ਸਬੰਧਤ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ, ਸਾਨੂੰ ਨਿਯਮ ਦੇ ਗਲਤ ਸਕਾਰਾਤਮਕਤਾਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ ਹੈ ਜੋ ਅਸਪਸ਼ਟਤਾ ਸੈਟਿੰਗ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਤੱਥ ਇਹ ਹੈ ਕਿ ਬਾਕਸ ਦੇ ਬਾਹਰ ਨਿਯਮ ਫਾਈਲ ਵਿੱਚ ਖੋਜ ਕਰਦਾ ਹੈ build.gradle ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਰੀਲੀਜ਼ ਸੰਸਕਰਣ ਲਈ ਗੁੰਝਲਦਾਰ ਨਿਯਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਸੈਟਿੰਗ।

ਪਰ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਕਈ ਵਾਰ ਚਾਈਲਡ ਫਾਈਲਾਂ ਹੁੰਦੀਆਂ ਹਨ build.gradle, ਜੋ ਕਿ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸ਼ਾਮਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ। ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਭਾਵੇਂ ਇਹ ਫਾਈਲਾਂ ਗੁੰਝਲਦਾਰ ਹੋਣ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਨਹੀਂ ਹਨ, ਪਰ ਸੰਕਲਨ ਦੇ ਦੌਰਾਨ ਪੇਰੈਂਟ ਅਸੈਂਬਲੀ ਫਾਈਲ ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ.

ਇਸ ਤਰ੍ਹਾਂ, ਕੰਮ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਸਬੰਧਤ ਚਾਈਲਡ ਫਾਈਲਾਂ ਵਿੱਚ ਟਰਿਗਰਾਂ ਨੂੰ ਕੱਟਣਾ ਹੈ। ਉਹਨਾਂ ਨੂੰ ਲਾਈਨ ਦੀ ਮੌਜੂਦਗੀ ਦੁਆਰਾ ਪਛਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ apply 'com.android.library'.

ਫਾਈਲ ਤੋਂ ਉਦਾਹਰਨ ਕੋਡ build.gradle, ਜੋ ਕਿ ਗੁੰਝਲਦਾਰਤਾ ਦੀ ਲੋੜ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.2"
    defaultConfig {
        ...
    }

    buildTypes {
        release {
            minifyEnabled true
            ...
        }
    }
}

dependencies {
  ...
}

ਫਾਈਲ ਉਦਾਹਰਨ build.gradle ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸ਼ਾਮਲ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਲਈ ਜਿਸ ਵਿੱਚ ਇਹ ਸੈਟਿੰਗ ਨਹੀਂ ਹੈ:

apply plugin: 'android-library'

dependencies {
  compile 'com.android.support:support-v4:18.0.+'
}

android {
  compileSdkVersion 14
  buildToolsVersion '17.0.0'
  ...
}

ਅਤੇ ਚੈੱਕਮਾਰਕਸ ਲਈ ਨਿਯਮ:

ProGuardObfuscationNotInUse

// Поиск метода release среди всех методов в Gradle файлах
CxList releaseMethod = Find_Gradle_Method("release");

// Все объекты из файлов build.gradle
CxList gradleBuildObjects = Find_Gradle_Build_Objects();

// Поиск того, что находится внутри метода "release" среди всех объектов из файлов build.gradle
CxList methodInvokesUnderRelease = gradleBuildObjects.FindByType(typeof(MethodInvokeExpr)).GetByAncs(releaseMethod);

// Ищем внутри gradle-файлов строку "com.android.library" - это значит, что данный файл относится к библиотеке и его необходимо исключить из правила
CxList android_library = gradleBuildObjects.FindByName("com.android.library");

// Инициализация пустого массива
List<string> libraries_path = new List<string> {};

// Проходим через все найденные "дочерние" файлы
foreach(CxList library in android_library)
{
    // Получаем путь к каждому файлу
	string file_name_library = library.GetFirstGraph().LinePragma.FileName;
    
    // Добавляем его в наш массив
	libraries_path.Add(file_name_library);
}

// Ищем все вызовы включения обфускации в релизных настройках
CxList minifyEnabled = methodInvokesUnderRelease.FindByShortName("minifyEnabled");

// Получаем параметры этих вызовов
CxList minifyValue = gradleBuildObjects.GetParameters(minifyEnabled, 0);

// Ищем среди них включенные
CxList minifyValueTrue = minifyValue.FindByShortName("true");

// Немного магии, если не нашли стандартным способом :D
if (minifyValueTrue.Count == 0) {
	minifyValue = minifyValue.FindByAbstractValue(abstractValue => abstractValue is TrueAbstractValue);
} else {
    // А если всё-таки нашли, то предыдущий результат и оставляем
	minifyValue = minifyValueTrue;	
}

// Если не нашлось таких методов
if (minifyValue.Count == 0)
{
    // Для более корректного отображения места срабатывания в файле ищем или buildTypes или android
	CxList tempResult = All.NewCxList();
	CxList buildTypes = Find_Gradle_Method("buildTypes");
	if (buildTypes.Count > 0) {
		tempResult = buildTypes;
	} else {
		tempResult = Find_Gradle_Method("android");
	}
	
	// Для каждого из найденных мест срабатывания проходим и определяем, дочерний или основной файлы сборки
	foreach(CxList res in tempResult)
	{
        // Определяем, в каком файле был найден buildType или android методы
		string file_name_result = res.GetFirstGraph().LinePragma.FileName;
        
        // Если такого файла нет в нашем списке "дочерних" файлов - значит это основной файл и его можно добавить в результат
		if (libraries_path.Contains(file_name_result) == false){
			result.Add(res);
		}
	}
}

ਇਹ ਪਹੁੰਚ ਕਾਫ਼ੀ ਵਿਆਪਕ ਅਤੇ ਉਪਯੋਗੀ ਹੋ ਸਕਦੀ ਹੈ ਨਾ ਸਿਰਫ਼ ਐਂਡਰੌਇਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ, ਸਗੋਂ ਹੋਰ ਮਾਮਲਿਆਂ ਲਈ ਵੀ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਕੀ ਨਤੀਜਾ ਕਿਸੇ ਖਾਸ ਫਾਈਲ ਨਾਲ ਸਬੰਧਤ ਹੈ।

ਚੁਣੌਤੀ: ਜੇਕਰ ਸੰਟੈਕਸ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ ਤਾਂ ਤੀਜੀ ਧਿਰ ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਲਈ ਸਮਰਥਨ ਸ਼ਾਮਲ ਕਰੋ

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

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

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

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

ਨਮੂਨਾ ਕੋਡ:

// В общем случае - значения, контролируемые пользователем
val table = "coffees"
sql"select * from #$table where name = $name".as[Coffee].headOption

ਚੈਕਮਾਰਕਸ ਨੂੰ ਅਜੇ ਤੱਕ ਇਹ ਨਹੀਂ ਪਤਾ ਹੈ ਕਿ ਸਪਲੀਸਿੰਗ ਲਿਟਰਲ ਵੈਲਯੂਜ਼ ਅਤੇ ਸਕਿੱਪ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਕਿਵੇਂ ਖੋਜਣਾ ਹੈ #$, ਤਾਂ ਆਓ ਇਸਨੂੰ ਸੰਭਾਵੀ SQL ਇੰਜੈਕਸ਼ਨਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਕੋਡ ਵਿੱਚ ਸਹੀ ਸਥਾਨਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਨ ਲਈ ਸਿਖਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

// Находим все импорты
CxList imports = All.FindByType(typeof(Import));

// Ищем по имени, есть ли в импортах slick
CxList slick = imports.FindByShortName("slick");

// Некоторый флаг, определяющий, что импорт библиотеки в коде присутствует
// Для более точного определения - можно применить подход с именем файла
bool not_empty_list = false;
foreach (CxList r in slick)
{
    // Если встретили импорт, считаем, что slick используется
	not_empty_list = true;
}

if (not_empty_list) {
    // Ищем вызовы, в которые передается SQL-строка
	CxList sql = All.FindByShortName("sql");
	sql.Add(All.FindByShortName("sqlu"));
	
	// Определяем данные, которые попадают в эти вызовы
	CxList data_sql = All.DataInfluencingOn(sql);
	
	// Так как синтакис не поддерживается, можно применить подход с регулярными выражениями
	// RegExp стоит использовать крайне осторожно и не применять его на большом количестве данных, так как это может сильно повлиять на производительность
	CxList find_possible_inj = data_sql.FindByRegex(@"#$", true, true, true);

    // Избавляемся от лишних срабатываний, если они есть и выводим в результат
	result = find_possible_inj.FindByType(typeof(BinaryExpr));
}

ਚੁਣੌਤੀ: ਓਪਨ-ਸੋਰਸ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਵਰਤੇ ਗਏ ਕਮਜ਼ੋਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਖੋਜ ਕਰੋ

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

ਪਰ ਕਈ ਵਾਰ, ਖਾਸ ਤੌਰ 'ਤੇ JavaScript 'ਤੇ ਵਿਚਾਰ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਾਮੂਲੀ ਕੰਮ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ਹੇਠਾਂ ਇੱਕ ਹੱਲ ਹੈ, ਸ਼ਾਇਦ ਆਦਰਸ਼ ਨਹੀਂ, ਪਰ ਫਿਰ ਵੀ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਕੰਪੋਨੈਂਟ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ lodash ਢੰਗਾਂ ਵਿੱਚ template и *set.

ਇੱਕ JS ਫਾਈਲ ਵਿੱਚ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਕਮਜ਼ੋਰ ਕੋਡ ਦੀ ਜਾਂਚ ਦੀਆਂ ਉਦਾਹਰਨਾਂ:

/**
 * Template example
 */

'use strict';
var _ = require("./node_modules/lodash.js");


// Use the "interpolate" delimiter to create a compiled template.
var compiled = _.template('hello <%= js %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

// Use the internal `print` function in "evaluate" delimiters.

var compiled = _.template('<% print("hello " + js); %>!');
console.log(compiled({ 'js': 'lodash' }));
// => 'hello lodash!'

ਅਤੇ ਜਦੋਂ ਸਿੱਧੇ html ਵਿੱਚ ਜੁੜਦੇ ਹੋ:

<!DOCTYPE html>
<html>
<head>
    <title>Lodash Tutorial</title>
    <script src="./node_modules/lodash.js"></script>
    <script type="text/javascript">
  // Lodash chunking array
        nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];

        let c1 = _.template('<% print("hello " + js); %>!');
        console.log(c1);

        let c2 = _.template('<% print("hello " + js); %>!');
        console.log(c2);
    </script>
</head>
<body></body>
</html>

ਅਸੀਂ ਆਪਣੇ ਸਾਰੇ ਕਮਜ਼ੋਰ ਢੰਗਾਂ ਦੀ ਤਲਾਸ਼ ਕਰ ਰਹੇ ਹਾਂ, ਜੋ ਕਿ ਕਮਜ਼ੋਰੀਆਂ ਵਿੱਚ ਸੂਚੀਬੱਧ ਹਨ:

// Ищем все строки: в которых встречается строка lodash (предполагаем, что это объявление импорта библиотеки
CxList lodash_strings = Find_String_Literal().FindByShortName("*lodash*");

// Ищем все данные: которые взаимодействуют с этими строками
CxList data_on_lodash = All.InfluencedBy(lodash_strings);


// Задаем список уязвимых методов
List<string> vulnerable_methods = new List<string> {"template", "*set"};

// Ищем все наши уязвимые методы, которые перечисленны в уязвимостях и отфильтровываем их только там, где они вызывались
CxList vulnerableMethods = All.FindByShortNames(vulnerable_methods).FindByType(typeof(MethodInvokeExpr));

//Находим все данные: которые взаимодействуют с данными методами
CxList vulnFlow = All.InfluencedBy(vulnerableMethods);

// Если есть пересечение по этим данным - кладем в результат
result = vulnFlow * data_on_lodash;

// Формируем список путей по которым мы уже прошли, чтобы фильтровать в дальнейшем дубли
List<string> lodash_result_path = new List<string> {};

foreach(CxList lodash_result in result)
{
    // Очередной раз получаем пути к файлам
	string file_name = lodash_result.GetFirstGraph().LinePragma.FileName;
	lodash_result_path.Add(file_name);
}

// Дальше идет часть относящаяся к html файлам, так как в них мы не можем проследить откуда именно идет вызов
// Формируем массив путей файлов, чтобы быть уверенными, что срабатывания уязвимых методов были именно в тех файлах, в которых объявлен lodash
List<string> lodash_path = new List<string> {};
foreach(CxList string_lodash in lodash_strings)
{
	string file_name = string_lodash.GetFirstGraph().LinePragma.FileName;
	lodash_path.Add(file_name);
}

// Перебираем все уязвимые методы и убеждаемся, что они вызваны в тех же файлах, что и объявление/включение lodash
foreach(CxList method in vulnerableMethods)
{
	string file_name_method = method.GetFirstGraph().LinePragma.FileName;
	if (lodash_path.Contains(file_name_method) == true && lodash_result_path.Contains(file_name_method) == false){
		result.Add(method);
	}
}

// Убираем все UknownReferences и оставляем самый "длинный" из путей, если такие встречаются
result = result.ReduceFlow(CxList.ReduceFlowType.ReduceSmallFlow) - result.FindByType(typeof(UnknownReference));

ਚੁਣੌਤੀ: ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਸਰਟੀਫਿਕੇਟਾਂ ਦੀ ਖੋਜ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

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

// Найдем все сертификаты по маске файла
CxList find_certs = All.FindByShortNames(new List<string> {"*.der", "*.cer", "*.pem", "*.key"}, false);

// Проверим, где в приложении они используются
CxList data_used_certs = All.DataInfluencedBy(find_certs);

// И для мобильных приложений - можем поискать методы, где вызывается чтение сертификатов
// Для других платформ и приложений могут быть различные методы
CxList methods = All.FindByMemberAccess("*.getAssets");

// Пересечение множеств даст нам результат по использованию локальных сертификатов в приложении
result = methods * data_used_certs;

ਚੁਣੌਤੀ: ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸਮਝੌਤਾ ਕੀਤੇ ਟੋਕਨਾਂ ਨੂੰ ਲੱਭਣਾ

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

// Получаем все строки, которые содержатся в коде
CxList strings = base.Find_Strings();

// Ищем среди всех строк нужное нам значение. В примере токен в виде строки "qwerty12345"
result = strings.FindByShortName("qwerty12345");

ਸਿੱਟਾ

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

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਵਰਤਮਾਨ ਵਿੱਚ ਇੱਕ ਸਰੋਤ ਦੀ ਘਾਟ ਹੈ ਜਿੱਥੇ ਚੈੱਕਮਾਰਕਸ ਲਈ ਨਿਯਮਾਂ ਦੇ ਵਿਕਾਸ ਦੌਰਾਨ ਨਵੇਂ ਵਿਚਾਰ ਇਕੱਠੇ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ ਅਸੀਂ ਬਣਾਇਆ ਹੈ Github 'ਤੇ ਰਿਪੋਜ਼ਟਰੀ, ਜਿੱਥੇ ਅਸੀਂ ਆਪਣਾ ਕੰਮ ਪੋਸਟ ਕਰਾਂਗੇ ਤਾਂ ਜੋ CxQL ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਹਰ ਵਿਅਕਤੀ ਨੂੰ ਇਸ ਵਿੱਚ ਕੁਝ ਲਾਭਦਾਇਕ ਲੱਭ ਸਕੇ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਆਪਣੇ ਕੰਮ ਨੂੰ ਕਮਿਊਨਿਟੀ ਨਾਲ ਸਾਂਝਾ ਕਰਨ ਦਾ ਮੌਕਾ ਵੀ ਮਿਲੇ। ਰਿਪੋਜ਼ਟਰੀ ਸਮੱਗਰੀ ਨੂੰ ਭਰਨ ਅਤੇ ਢਾਂਚਾ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਹੈ, ਇਸ ਲਈ ਯੋਗਦਾਨ ਪਾਉਣ ਵਾਲਿਆਂ ਦਾ ਸੁਆਗਤ ਹੈ!

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ!

ਸਰੋਤ: www.habr.com

ਬਿਨਾਂ ਪਾਗਲ ਹੋਏ ਚੈੱਕਮਾਰਕਸ ਲਈ ਨਿਯਮ ਕਿਵੇਂ ਲਿਖਣੇ ਹਨ