UC ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਭਾਲ ਕਰ ਰਿਹਾ ਹੈ

ਜਾਣ ਪਛਾਣ

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

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

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

ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿੱਚ, ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਕੋਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਖੋਜੀ ਗਈ ਸੀ, ਜੋ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਦੇ ਨਿਯਮਾਂ ਦੇ ਉਲਟ ਹੈ Google Play 'ਤੇ। ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਕੋਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਇਲਾਵਾ, UC ਬ੍ਰਾਊਜ਼ਰ ਅਜਿਹਾ ਅਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਕਰਦਾ ਹੈ, ਜਿਸ ਦੀ ਵਰਤੋਂ MitM ਹਮਲੇ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਆਓ ਦੇਖੀਏ ਕਿ ਕੀ ਅਸੀਂ ਅਜਿਹਾ ਹਮਲਾ ਕਰ ਸਕਦੇ ਹਾਂ।

ਹੇਠਾਂ ਲਿਖੀ ਹਰ ਚੀਜ਼ UC ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਸੰਸਕਰਣ ਲਈ ਢੁਕਵੀਂ ਹੈ ਜੋ ਅਧਿਐਨ ਦੇ ਸਮੇਂ Google Play 'ਤੇ ਉਪਲਬਧ ਸੀ:

package: com.UCMobile.intl
versionName: 12.10.8.1172
versionCode: 10598
sha1 APK-файла: f5edb2243413c777172f6362876041eb0c3a928c

ਹਮਲਾ ਵੈਕਟਰ

UC ਬਰਾਊਜ਼ਰ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ਤੁਸੀਂ ਸਵੈ-ਵਿਆਖਿਆਤਮਕ ਨਾਮ ਵਾਲੀ ਸੇਵਾ ਲੱਭ ਸਕਦੇ ਹੋ com.uc.deployment.UpgradeDeployService.

    <service android_exported="false" android_name="com.uc.deployment.UpgradeDeployService" android_process=":deploy" />

ਜਦੋਂ ਇਹ ਸੇਵਾ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਬ੍ਰਾਊਜ਼ਰ ਪੋਸਟ ਕਰਨ ਲਈ ਬੇਨਤੀ ਕਰਦਾ ਹੈ puds.ucweb.com/upgrade/index.xhtml, ਜੋ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਕੁਝ ਸਮੇਂ ਬਾਅਦ ਟ੍ਰੈਫਿਕ ਵਿੱਚ ਦੇਖੀ ਜਾ ਸਕਦੀ ਹੈ। ਜਵਾਬ ਵਿੱਚ, ਉਸਨੂੰ ਕੁਝ ਅੱਪਡੇਟ ਜਾਂ ਨਵਾਂ ਮੋਡੀਊਲ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਕਮਾਂਡ ਪ੍ਰਾਪਤ ਹੋ ਸਕਦੀ ਹੈ। ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਦੌਰਾਨ, ਸਰਵਰ ਨੇ ਅਜਿਹੀਆਂ ਕਮਾਂਡਾਂ ਨਹੀਂ ਦਿੱਤੀਆਂ, ਪਰ ਅਸੀਂ ਦੇਖਿਆ ਕਿ ਜਦੋਂ ਅਸੀਂ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇੱਕ PDF ਖੋਲ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਉੱਪਰ ਦੱਸੇ ਪਤੇ 'ਤੇ ਦੂਜੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਨੇਟਿਵ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ। ਹਮਲੇ ਨੂੰ ਅੰਜਾਮ ਦੇਣ ਲਈ, ਅਸੀਂ UC ਬ੍ਰਾਊਜ਼ਰ ਦੀ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ: ਇੱਕ ਮੂਲ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ PDF ਖੋਲ੍ਹਣ ਦੀ ਸਮਰੱਥਾ, ਜੋ ਕਿ ਏਪੀਕੇ ਵਿੱਚ ਨਹੀਂ ਹੈ ਅਤੇ ਜੇ ਲੋੜ ਪੈਣ 'ਤੇ ਇਹ ਇੰਟਰਨੈਟ ਤੋਂ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ। ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ, ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਯੂਸੀ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਉਪਭੋਗਤਾ ਦੀ ਆਪਸੀ ਤਾਲਮੇਲ ਤੋਂ ਬਿਨਾਂ ਕੁਝ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ - ਜੇਕਰ ਤੁਸੀਂ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਲਾਂਚ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕੀਤੀ ਗਈ ਬੇਨਤੀ ਲਈ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਜਵਾਬ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ। ਪਰ ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਰਵਰ ਨਾਲ ਗੱਲਬਾਤ ਦੇ ਪ੍ਰੋਟੋਕੋਲ ਦਾ ਵਧੇਰੇ ਵਿਸਥਾਰ ਨਾਲ ਅਧਿਐਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਕਿ ਪੀਡੀਐਫ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੰਟਰਸੈਪਟਡ ਜਵਾਬ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨਾ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਬਦਲਣਾ ਆਸਾਨ ਹੋਵੇਗਾ।

ਇਸ ਲਈ, ਜਦੋਂ ਕੋਈ ਉਪਭੋਗਤਾ ਸਿੱਧੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇੱਕ PDF ਖੋਲ੍ਹਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਟ੍ਰੈਫਿਕ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

ਪਹਿਲਾਂ ਇੱਕ POST ਬੇਨਤੀ ਹੈ puds.ucweb.com/upgrade/index.xhtmlਜਿਸ ਦੇ ਬਾਅਦ
PDF ਅਤੇ ਦਫ਼ਤਰ ਫਾਰਮੈਟਾਂ ਨੂੰ ਦੇਖਣ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਾਲਾ ਇੱਕ ਆਰਕਾਈਵ ਡਾਊਨਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਮੰਨਣਾ ਲਾਜ਼ੀਕਲ ਹੈ ਕਿ ਪਹਿਲੀ ਬੇਨਤੀ ਸਿਸਟਮ (ਲੋੜੀਂਦੀ ਲਾਇਬ੍ਰੇਰੀ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਘੱਟੋ-ਘੱਟ ਆਰਕੀਟੈਕਚਰ) ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਸਾਰਿਤ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸਦੇ ਜਵਾਬ ਵਿੱਚ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਲਾਇਬ੍ਰੇਰੀ ਬਾਰੇ ਕੁਝ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ ਜਿਸ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ: ਪਤਾ ਅਤੇ, ਸੰਭਵ ਤੌਰ 'ਤੇ , ਕੁਝ ਹੋਰ. ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇਹ ਬੇਨਤੀ ਏਨਕ੍ਰਿਪਟ ਕੀਤੀ ਗਈ ਹੈ।

ਟੁਕੜੇ ਦੀ ਬੇਨਤੀ ਕਰੋ

ਜਵਾਬ ਟੁਕੜਾ

ਲਾਇਬ੍ਰੇਰੀ ਖੁਦ ਜ਼ਿਪ ਵਿੱਚ ਪੈਕ ਕੀਤੀ ਗਈ ਹੈ ਅਤੇ ਐਨਕ੍ਰਿਪਟਡ ਨਹੀਂ ਹੈ।

ਟ੍ਰੈਫਿਕ ਡੀਕ੍ਰਿਪਸ਼ਨ ਕੋਡ ਦੀ ਖੋਜ ਕਰੋ

ਆਉ ਸਰਵਰ ਜਵਾਬ ਨੂੰ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਆਉ ਕਲਾਸ ਕੋਡ ਨੂੰ ਵੇਖੀਏ com.uc.deployment.UpgradeDeployService: ਵਿਧੀ ਤੋਂ onStartCommand ਵੱਲ ਜਾ com.uc.deployment.bx, ਅਤੇ ਇਸ ਤੋਂ ਤੱਕ com.uc.browser.core.dcfe:

    public final void e(l arg9) {
int v4_5;
String v3_1;
byte[] v3;
byte[] v1 = null;
if(arg9 == null) {
v3 = v1;
}
else {
v3_1 = arg9.iGX.ipR;
StringBuilder v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]product:");
v4.append(arg9.iGX.ipR);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]version:");
v4.append(arg9.iGX.iEn);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]upgrade_type:");
v4.append(arg9.iGX.mMode);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]force_flag:");
v4.append(arg9.iGX.iEo);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_mode:");
v4.append(arg9.iGX.iDQ);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_type:");
v4.append(arg9.iGX.iEr);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_state:");
v4.append(arg9.iGX.iEp);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_file:");
v4.append(arg9.iGX.iEq);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apk_md5:");
v4.append(arg9.iGX.iEl);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_type:");
v4.append(arg9.mDownloadType);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_group:");
v4.append(arg9.mDownloadGroup);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_path:");
v4.append(arg9.iGH);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_child_version:");
v4.append(arg9.iGX.iEx);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_series:");
v4.append(arg9.iGX.iEw);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_arch:");
v4.append(arg9.iGX.iEt);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp3:");
v4.append(arg9.iGX.iEv);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp:");
v4.append(arg9.iGX.iEu);
ArrayList v3_2 = arg9.iGX.iEz;
if(v3_2 != null && v3_2.size() != 0) {
Iterator v3_3 = v3_2.iterator();
while(v3_3.hasNext()) {
Object v4_1 = v3_3.next();
StringBuilder v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_name:");
v5.append(((au)v4_1).getName());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_name:");
v5.append(((au)v4_1).aDA());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_code:");
v5.append(((au)v4_1).gBl);
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_req_type:");
v5.append(((au)v4_1).gBq);
}
}
j v3_4 = new j();
m.b(v3_4);
h v4_2 = new h();
m.b(v4_2);
ay v5_1 = new ay();
v3_4.hS("");
v3_4.setImsi("");
v3_4.hV("");
v5_1.bPQ = v3_4;
v5_1.bPP = v4_2;
v5_1.yr(arg9.iGX.ipR);
v5_1.gBF = arg9.iGX.mMode;
v5_1.gBI = arg9.iGX.iEz;
v3_2 = v5_1.gAr;
c.aBh();
v3_2.add(g.fs("os_ver", c.getRomInfo()));
v3_2.add(g.fs("processor_arch", com.uc.b.a.a.c.getCpuArch()));
v3_2.add(g.fs("cpu_arch", com.uc.b.a.a.c.Pb()));
String v4_3 = com.uc.b.a.a.c.Pd();
v3_2.add(g.fs("cpu_vfp", v4_3));
v3_2.add(g.fs("net_type", String.valueOf(com.uc.base.system.a.Jo())));
v3_2.add(g.fs("fromhost", arg9.iGX.iEm));
v3_2.add(g.fs("plugin_ver", arg9.iGX.iEn));
v3_2.add(g.fs("target_lang", arg9.iGX.iEs));
v3_2.add(g.fs("vitamio_cpu_arch", arg9.iGX.iEt));
v3_2.add(g.fs("vitamio_vfp", arg9.iGX.iEu));
v3_2.add(g.fs("vitamio_vfp3", arg9.iGX.iEv));
v3_2.add(g.fs("plugin_child_ver", arg9.iGX.iEx));
v3_2.add(g.fs("ver_series", arg9.iGX.iEw));
v3_2.add(g.fs("child_ver", r.aVw()));
v3_2.add(g.fs("cur_ver_md5", arg9.iGX.iEl));
v3_2.add(g.fs("cur_ver_signature", SystemHelper.getUCMSignature()));
v3_2.add(g.fs("upgrade_log", i.bjt()));
v3_2.add(g.fs("silent_install", String.valueOf(arg9.iGX.iDQ)));
v3_2.add(g.fs("silent_state", String.valueOf(arg9.iGX.iEp)));
v3_2.add(g.fs("silent_file", arg9.iGX.iEq));
v3_2.add(g.fs("silent_type", String.valueOf(arg9.iGX.iEr)));
v3_2.add(g.fs("cpu_archit", com.uc.b.a.a.c.Pc()));
v3_2.add(g.fs("cpu_set", SystemHelper.getCpuInstruction()));
boolean v4_4 = v4_3 == null || !v4_3.contains("neon") ? false : true;
v3_2.add(g.fs("neon", String.valueOf(v4_4)));
v3_2.add(g.fs("cpu_cores", String.valueOf(com.uc.b.a.a.c.Jl())));
v3_2.add(g.fs("ram_1", String.valueOf(com.uc.b.a.a.h.Po())));
v3_2.add(g.fs("totalram", String.valueOf(com.uc.b.a.a.h.OL())));
c.aBh();
v3_2.add(g.fs("rom_1", c.getRomInfo()));
v4_5 = e.getScreenWidth();
int v6 = e.getScreenHeight();
StringBuilder v7 = new StringBuilder();
v7.append(v4_5);
v7.append("*");
v7.append(v6);
v3_2.add(g.fs("ss", v7.toString()));
v3_2.add(g.fs("api_level", String.valueOf(Build$VERSION.SDK_INT)));
v3_2.add(g.fs("uc_apk_list", SystemHelper.getUCMobileApks()));
Iterator v4_6 = arg9.iGX.iEA.entrySet().iterator();
while(v4_6.hasNext()) {
Object v6_1 = v4_6.next();
v3_2.add(g.fs(((Map$Entry)v6_1).getKey(), ((Map$Entry)v6_1).getValue()));
}
v3 = v5_1.toByteArray();
}
if(v3 == null) {
this.iGY.iGI.a(arg9, "up_encode", "yes", "fail");
return;
}
v4_5 = this.iGY.iGw ? 0x1F : 0;
if(v3 == null) {
}
else {
v3 = g.i(v4_5, v3);
if(v3 == null) {
}
else {
v1 = new byte[v3.length + 16];
byte[] v6_2 = new byte[16];
Arrays.fill(v6_2, 0);
v6_2[0] = 0x5F;
v6_2[1] = 0;
v6_2[2] = ((byte)v4_5);
v6_2[3] = -50;
System.arraycopy(v6_2, 0, v1, 0, 16);
System.arraycopy(v3, 0, v1, 16, v3.length);
}
}
if(v1 == null) {
this.iGY.iGI.a(arg9, "up_encrypt", "yes", "fail");
return;
}
if(TextUtils.isEmpty(this.iGY.mUpgradeUrl)) {
this.iGY.iGI.a(arg9, "up_url", "yes", "fail");
return;
}
StringBuilder v0 = new StringBuilder("[");
v0.append(arg9.iGX.ipR);
v0.append("]url:");
v0.append(this.iGY.mUpgradeUrl);
com.uc.browser.core.d.c.i v0_1 = this.iGY.iGI;
v3_1 = this.iGY.mUpgradeUrl;
com.uc.base.net.e v0_2 = new com.uc.base.net.e(new com.uc.browser.core.d.c.i$a(v0_1, arg9));
v3_1 = v3_1.contains("?") ? v3_1 + "&dataver=pb" : v3_1 + "?dataver=pb";
n v3_5 = v0_2.uc(v3_1);
m.b(v3_5, false);
v3_5.setMethod("POST");
v3_5.setBodyProvider(v1);
v0_2.b(v3_5);
this.iGY.iGI.a(arg9, "up_null", "yes", "success");
this.iGY.iGI.b(arg9);
}

ਅਸੀਂ ਇੱਥੇ ਇੱਕ POST ਬੇਨਤੀ ਦਾ ਗਠਨ ਦੇਖਦੇ ਹਾਂ। ਅਸੀਂ 16 ਬਾਈਟਾਂ ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਉਣ ਅਤੇ ਇਸ ਦੇ ਭਰਨ ਵੱਲ ਧਿਆਨ ਦਿੰਦੇ ਹਾਂ: 0x5F, 0, 0x1F, -50 (=0xCE). ਉਸ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜੋ ਅਸੀਂ ਉਪਰੋਕਤ ਬੇਨਤੀ ਵਿੱਚ ਦੇਖਿਆ ਹੈ।

ਉਸੇ ਕਲਾਸ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕ ਨੇਸਟਡ ਕਲਾਸ ਦੇਖ ਸਕਦੇ ਹੋ ਜਿਸਦਾ ਇੱਕ ਹੋਰ ਦਿਲਚਸਪ ਤਰੀਕਾ ਹੈ:

        public final void a(l arg10, byte[] arg11) {
f v0 = this.iGQ;
StringBuilder v1 = new StringBuilder("[");
v1.append(arg10.iGX.ipR);
v1.append("]:UpgradeSuccess");
byte[] v1_1 = null;
if(arg11 == null) {
}
else if(arg11.length < 16) {
}
else {
if(arg11[0] != 0x60 && arg11[3] != 0xFFFFFFD0) {
goto label_57;
}
int v3 = 1;
int v5 = arg11[1] == 1 ? 1 : 0;
if(arg11[2] != 1 && arg11[2] != 11) {
if(arg11[2] == 0x1F) {
}
else {
v3 = 0;
}
}
byte[] v7 = new byte[arg11.length - 16];
System.arraycopy(arg11, 16, v7, 0, v7.length);
if(v3 != 0) {
v7 = g.j(arg11[2], v7);
}
if(v7 == null) {
goto label_57;
}
if(v5 != 0) {
v1_1 = g.P(v7);
goto label_57;
}
v1_1 = v7;
}
label_57:
if(v1_1 == null) {
v0.iGY.iGI.a(arg10, "up_decrypt", "yes", "fail");
return;
}
q v11 = g.b(arg10, v1_1);
if(v11 == null) {
v0.iGY.iGI.a(arg10, "up_decode", "yes", "fail");
return;
}
if(v0.iGY.iGt) {
v0.d(arg10);
}
if(v0.iGY.iGo != null) {
v0.iGY.iGo.a(0, ((o)v11));
}
if(v0.iGY.iGs) {
v0.iGY.a(((o)v11));
v0.iGY.iGI.a(v11, "up_silent", "yes", "success");
v0.iGY.iGI.a(v11);
return;
}
v0.iGY.iGI.a(v11, "up_silent", "no", "success");
}
}

ਵਿਧੀ ਇੰਪੁੱਟ ਦੇ ਤੌਰ 'ਤੇ ਬਾਈਟਾਂ ਦੀ ਇੱਕ ਐਰੇ ਲੈਂਦੀ ਹੈ ਅਤੇ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਜ਼ੀਰੋ ਬਾਈਟ 0x60 ਹੈ ਜਾਂ ਤੀਜੀ ਬਾਈਟ 0xD0 ਹੈ, ਅਤੇ ਦੂਜੀ ਬਾਈਟ 1, 11 ਜਾਂ 0x1F ਹੈ। ਅਸੀਂ ਸਰਵਰ ਤੋਂ ਜਵਾਬ ਦੇਖਦੇ ਹਾਂ: ਜ਼ੀਰੋ ਬਾਈਟ 0x60 ਹੈ, ਦੂਜਾ 0x1F ਹੈ, ਤੀਜਾ 0x60 ਹੈ। ਸਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ ਵਰਗਾ ਆਵਾਜ਼. ਲਾਈਨਾਂ ਦੁਆਰਾ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ (“up_decrypt”, ਉਦਾਹਰਨ ਲਈ), ਇੱਥੇ ਇੱਕ ਵਿਧੀ ਨੂੰ ਬੁਲਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਸਰਵਰ ਦੇ ਜਵਾਬ ਨੂੰ ਡੀਕ੍ਰਿਪਟ ਕਰੇਗਾ।
ਆਓ ਵਿਧੀ ਵੱਲ ਵਧੀਏ ਜੀਜੇ. ਨੋਟ ਕਰੋ ਕਿ ਪਹਿਲਾ ਆਰਗੂਮੈਂਟ ਔਫਸੈੱਟ 2 'ਤੇ ਬਾਈਟ ਹੈ (ਜਿਵੇਂ ਕਿ ਸਾਡੇ ਕੇਸ ਵਿੱਚ 0x1F), ਅਤੇ ਦੂਜਾ ਬਿਨਾਂ ਸਰਵਰ ਜਵਾਬ ਹੈ
ਪਹਿਲੇ 16 ਬਾਈਟ.

     public static byte[] j(int arg1, byte[] arg2) {
if(arg1 == 1) {
arg2 = c.c(arg2, c.adu);
}
else if(arg1 == 11) {
arg2 = m.aF(arg2);
}
else if(arg1 != 0x1F) {
}
else {
arg2 = EncryptHelper.decrypt(arg2);
}
return arg2;
}

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

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

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

    private static byte[] decryptBytesByKey(byte[] bytes) {
byte[] v0 = null;
if(bytes != null) {
try {
if(bytes.length < EncryptHelper.PREFIX_BYTES_SIZE) {
}
else if(bytes.length == EncryptHelper.PREFIX_BYTES_SIZE) {
return v0;
}
else {
byte[] prefix = new byte[EncryptHelper.PREFIX_BYTES_SIZE];  // 2 байта
System.arraycopy(bytes, 0, prefix, 0, prefix.length);
String keyId = c.ayR().d(ByteBuffer.wrap(prefix).getShort()); // Выбор ключа
if(keyId == null) {
return v0;
}
else {
a v2 = EncryptHelper.ayL();
if(v2 == null) {
return v0;
}
else {
byte[] enrypted = new byte[bytes.length - EncryptHelper.PREFIX_BYTES_SIZE];
System.arraycopy(bytes, EncryptHelper.PREFIX_BYTES_SIZE, enrypted, 0, enrypted.length);
return v2.l(keyId, enrypted);
}
}
}
}
catch(SecException v7_1) {
EncryptHelper.handleDecryptException(((Throwable)v7_1), v7_1.getErrorCode());
return v0;
}
catch(Throwable v7) {
EncryptHelper.handleDecryptException(v7, 2);
return v0;
}
}
return v0;
}

ਅੱਗੇ ਦੇਖਦੇ ਹੋਏ, ਅਸੀਂ ਨੋਟ ਕਰਦੇ ਹਾਂ ਕਿ ਇਸ ਪੜਾਅ 'ਤੇ ਸਾਨੂੰ ਅਜੇ ਕੋਈ ਕੁੰਜੀ ਨਹੀਂ ਮਿਲਦੀ ਹੈ, ਪਰ ਸਿਰਫ ਇਸਦਾ "ਪਛਾਣਕਰਤਾ" ਹੈ। ਕੁੰਜੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਥੋੜਾ ਹੋਰ ਗੁੰਝਲਦਾਰ ਹੈ।

ਅਗਲੀ ਵਿਧੀ ਵਿੱਚ, ਮੌਜੂਦਾ ਮਾਪਦੰਡਾਂ ਵਿੱਚ ਦੋ ਹੋਰ ਮਾਪਦੰਡ ਜੋੜੇ ਗਏ ਹਨ, ਉਹਨਾਂ ਵਿੱਚੋਂ ਚਾਰ ਬਣਾਉਂਦੇ ਹਨ: ਮੈਜਿਕ ਨੰਬਰ 16, ਕੁੰਜੀ ਪਛਾਣਕਰਤਾ, ਏਨਕ੍ਰਿਪਟਡ ਡੇਟਾ, ਅਤੇ ਇੱਕ ਨਾ ਸਮਝੀ ਜਾਣ ਵਾਲੀ ਸਤਰ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਖਾਲੀ)।

    public final byte[] l(String keyId, byte[] encrypted) throws SecException {
return this.ayJ().staticBinarySafeDecryptNoB64(16, keyId, encrypted, "");
}

ਤਬਦੀਲੀਆਂ ਦੀ ਇੱਕ ਲੜੀ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਵਿਧੀ 'ਤੇ ਪਹੁੰਚਦੇ ਹਾਂ staticBinarySafeDecryptNoB64 ਇੰਟਰਫੇਸ com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent. ਮੁੱਖ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿੱਚ ਕੋਈ ਕਲਾਸਾਂ ਨਹੀਂ ਹਨ ਜੋ ਇਸ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ। ਫਾਈਲ ਵਿੱਚ ਅਜਿਹੀ ਕਲਾਸ ਹੈ lib/armeabi-v7a/libsgmain.so, ਜੋ ਅਸਲ ਵਿੱਚ ਇੱਕ .so ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ .jar ਹੈ। ਉਹ ਵਿਧੀ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ, ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ:

package com.alibaba.wireless.security.a.i;
// ...
public class a implements IStaticDataEncryptComponent {
private ISecurityGuardPlugin a;
// ...
private byte[] a(int mode, int magicInt, int xzInt, String keyId, byte[] encrypted, String magicString) {
return this.a.getRouter().doCommand(10601, new Object[]{Integer.valueOf(mode), Integer.valueOf(magicInt), Integer.valueOf(xzInt), keyId, encrypted, magicString});
}
// ...
private byte[] b(int magicInt, String keyId, byte[] encrypted, String magicString) {
return this.a(2, magicInt, 0, keyId, encrypted, magicString);
}
// ...
public byte[] staticBinarySafeDecryptNoB64(int magicInt, String keyId, byte[] encrypted, String magicString) throws SecException {
if(keyId != null && keyId.length() > 0 && magicInt >= 0 && magicInt < 19 && encrypted != null && encrypted.length > 0) {
return this.b(magicInt, keyId, encrypted, magicString);
}
throw new SecException("", 301);
}
//...
}

ਇੱਥੇ ਸਾਡੇ ਮਾਪਦੰਡਾਂ ਦੀ ਸੂਚੀ ਦੋ ਹੋਰ ਪੂਰਨ ਅੰਕਾਂ ਨਾਲ ਪੂਰਕ ਹੈ: 2 ਅਤੇ 0. ਦੁਆਰਾ ਨਿਰਣਾ
ਸਭ ਕੁਝ, 2 ਦਾ ਅਰਥ ਹੈ ਡਿਕ੍ਰਿਪਸ਼ਨ, ਜਿਵੇਂ ਕਿ ਵਿਧੀ ਵਿੱਚ ਅੰਤਮ ਸਿਸਟਮ ਕਲਾਸ javax.crypto.Cipher. ਅਤੇ ਇਹ ਸਭ ਕੁਝ 10601 ਨੰਬਰ ਦੇ ਨਾਲ ਇੱਕ ਖਾਸ ਰਾਊਟਰ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ - ਇਹ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਕਮਾਂਡ ਨੰਬਰ ਹੈ.

ਪਰਿਵਰਤਨ ਦੀ ਅਗਲੀ ਲੜੀ ਤੋਂ ਬਾਅਦ ਸਾਨੂੰ ਇੱਕ ਕਲਾਸ ਮਿਲਦੀ ਹੈ ਜੋ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ IRouter ਕੰਪੋਨੈਂਟ ਅਤੇ ਢੰਗ doCommand:

package com.alibaba.wireless.security.mainplugin;
import com.alibaba.wireless.security.framework.IRouterComponent;
import com.taobao.wireless.security.adapter.JNICLibrary;
public class a implements IRouterComponent {
public a() {
super();
}
public Object doCommand(int arg2, Object[] arg3) {
return JNICLibrary.doCommandNative(arg2, arg3);
}
}

ਅਤੇ ਕਲਾਸ ਵੀ JNICL ਲਾਇਬ੍ਰੇਰੀ, ਜਿਸ ਵਿੱਚ ਮੂਲ ਵਿਧੀ ਘੋਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੈ doCommandNative:

package com.taobao.wireless.security.adapter;
public class JNICLibrary {
public static native Object doCommandNative(int arg0, Object[] arg1);
}

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਨੂੰ ਨੇਟਿਵ ਕੋਡ ਵਿੱਚ ਇੱਕ ਢੰਗ ਲੱਭਣ ਦੀ ਲੋੜ ਹੈ doCommandNative. ਅਤੇ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਮਜ਼ੇ ਦੀ ਸ਼ੁਰੂਆਤ ਹੁੰਦੀ ਹੈ.

ਮਸ਼ੀਨ ਕੋਡ ਦੀ ਗੜਬੜ

ਫਾਈਲ ਵਿੱਚ libsgmain.so (ਜੋ ਕਿ ਅਸਲ ਵਿੱਚ ਇੱਕ .jar ਹੈ ਅਤੇ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਕੁਝ ਐਨਕ੍ਰਿਪਸ਼ਨ-ਸਬੰਧਤ ਇੰਟਰਫੇਸਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ) ਇੱਥੇ ਇੱਕ ਮੂਲ ਲਾਇਬ੍ਰੇਰੀ ਹੈ: libsgmainso-6.4.36.so. ਅਸੀਂ ਇਸਨੂੰ IDA ਵਿੱਚ ਖੋਲ੍ਹਦੇ ਹਾਂ ਅਤੇ ਗਲਤੀਆਂ ਵਾਲੇ ਡਾਇਲਾਗ ਬਾਕਸਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਸੈਕਸ਼ਨ ਹੈਡਰ ਟੇਬਲ ਅਵੈਧ ਹੈ। ਇਹ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਗੁੰਝਲਦਾਰ ਕਰਨ ਲਈ ਮਕਸਦ 'ਤੇ ਕੀਤਾ ਗਿਆ ਹੈ.

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

IDA ਵਿੱਚ ਫਾਈਲ ਨੂੰ ਦੁਬਾਰਾ ਖੋਲ੍ਹੋ।

ਜਾਵਾ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਇਹ ਦੱਸਣ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ ਕਿ ਮੂਲ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਜਾਵਾ ਕੋਡ ਵਿੱਚ ਘੋਸ਼ਿਤ ਇੱਕ ਵਿਧੀ ਨੂੰ ਮੂਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕਿੱਥੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਇੱਕ ਪ੍ਰਜਾਤੀ ਦਾ ਨਾਮ ਦੇਣਾ ਹੈ Java_package_name_ClassName_MethodName.

ਦੂਜਾ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਲੋਡ ਕਰਨ ਵੇਲੇ ਇਸਨੂੰ ਰਜਿਸਟਰ ਕਰਨਾ ਹੈ (ਫੰਕਸ਼ਨ ਵਿੱਚ JNI_ਆਨਲੋਡ)
ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰਜਿਸਟਰ ਨੇਟਿਵ.

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਜੇ ਅਸੀਂ ਪਹਿਲੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਨਾਮ ਇਸ ਤਰ੍ਹਾਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: Java_com_taobao_wireless_security_adapter_JNICLlibrary_doCommandNative.

ਨਿਰਯਾਤ ਕੀਤੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਅਜਿਹਾ ਕੋਈ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਕਾਲ ਲੱਭਣ ਦੀ ਲੋੜ ਹੈ ਰਜਿਸਟਰ ਨੇਟਿਵ.
ਚਲੋ ਫੰਕਸ਼ਨ ਤੇ ਚੱਲੀਏ JNI_ਆਨਲੋਡ ਅਤੇ ਅਸੀਂ ਇਹ ਤਸਵੀਰ ਦੇਖਦੇ ਹਾਂ:

ਇੱਥੇ ਕੀ ਹੋ ਰਿਹਾ ਹੈ? ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ, ਫੰਕਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ARM ਆਰਕੀਟੈਕਚਰ ਲਈ ਖਾਸ ਹਨ। ਸਟੈਕ 'ਤੇ ਪਹਿਲੀ ਹਦਾਇਤ ਰਜਿਸਟਰਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਸਟੋਰ ਕਰਦੀ ਹੈ ਜੋ ਫੰਕਸ਼ਨ ਆਪਣੇ ਕੰਮ (ਇਸ ਕੇਸ ਵਿੱਚ, R0, R1 ਅਤੇ R2) ਵਿੱਚ ਵਰਤੇਗਾ, ਅਤੇ ਨਾਲ ਹੀ LR ਰਜਿਸਟਰ ਦੀ ਸਮੱਗਰੀ, ਜਿਸ ਵਿੱਚ ਫੰਕਸ਼ਨ ਤੋਂ ਵਾਪਸੀ ਦਾ ਪਤਾ ਹੁੰਦਾ ਹੈ। . ਆਖਰੀ ਹਦਾਇਤ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਰਜਿਸਟਰਾਂ ਨੂੰ ਬਹਾਲ ਕਰਦੀ ਹੈ, ਅਤੇ ਵਾਪਸੀ ਦਾ ਪਤਾ ਤੁਰੰਤ ਪੀਸੀ ਰਜਿਸਟਰ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ - ਇਸ ਤਰ੍ਹਾਂ ਫੰਕਸ਼ਨ ਤੋਂ ਵਾਪਸ ਆ ਰਿਹਾ ਹੈ। ਪਰ ਜੇ ਤੁਸੀਂ ਧਿਆਨ ਨਾਲ ਵੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਅੰਤਮ ਨਿਰਦੇਸ਼ ਸਟੈਕ 'ਤੇ ਸਟੋਰ ਕੀਤੇ ਵਾਪਸੀ ਦੇ ਪਤੇ ਨੂੰ ਬਦਲਦਾ ਹੈ. ਆਓ ਹਿਸਾਬ ਕਰੀਏ ਕਿ ਇਸ ਤੋਂ ਬਾਅਦ ਕਿਹੋ ਜਿਹਾ ਹੋਵੇਗਾ
ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ. ਇੱਕ ਖਾਸ ਪਤਾ 1xB0 ਨੂੰ R130 ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਵਿੱਚੋਂ 5 ਨੂੰ ਘਟਾਇਆ ਜਾਂਦਾ ਹੈ, ਫਿਰ ਇਸਨੂੰ R0 ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ 0x10 ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ 0xB13B ਬਾਹਰ ਕਾਮੁਕ. ਇਸ ਤਰ੍ਹਾਂ, IDA ਸੋਚਦਾ ਹੈ ਕਿ ਆਖਰੀ ਹਦਾਇਤ ਇੱਕ ਆਮ ਫੰਕਸ਼ਨ ਰਿਟਰਨ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ ਇਹ ਗਣਨਾ ਕੀਤੇ ਪਤੇ 0xB13B 'ਤੇ ਜਾ ਰਿਹਾ ਹੈ।

ਇੱਥੇ ਇਹ ਯਾਦ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ ARM ਪ੍ਰੋਸੈਸਰਾਂ ਦੇ ਦੋ ਮੋਡ ਅਤੇ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਦੋ ਸੈੱਟ ਹਨ: ARM ਅਤੇ ਥੰਬ। ਪਤੇ ਦਾ ਸਭ ਤੋਂ ਘੱਟ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਪ੍ਰੋਸੈਸਰ ਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਨਿਰਦੇਸ਼ ਸੈੱਟ ਵਰਤਿਆ ਜਾ ਰਿਹਾ ਹੈ। ਭਾਵ, ਪਤਾ ਅਸਲ ਵਿੱਚ 0xB13A ਹੈ, ਅਤੇ ਘੱਟੋ-ਘੱਟ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਵਿੱਚੋਂ ਇੱਕ ਥੰਬ ਮੋਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਹਰੇਕ ਫੰਕਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਇੱਕ ਸਮਾਨ “ਅਡਾਪਟਰ” ਜੋੜਿਆ ਗਿਆ ਹੈ ਅਤੇ
ਕੂੜਾ ਕੋਡ. ਅਸੀਂ ਉਹਨਾਂ 'ਤੇ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਵਿਚਾਰਾਂਗੇ - ਸਾਨੂੰ ਸਿਰਫ ਯਾਦ ਹੈ
ਕਿ ਲਗਭਗ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਅਸਲ ਸ਼ੁਰੂਆਤ ਥੋੜੀ ਦੂਰ ਹੈ।

ਕਿਉਂਕਿ ਕੋਡ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ 0xB13A 'ਤੇ ਨਹੀਂ ਜਾਂਦਾ ਹੈ, IDA ਨੇ ਖੁਦ ਇਹ ਨਹੀਂ ਪਛਾਣਿਆ ਕਿ ਕੋਡ ਇਸ ਸਥਾਨ 'ਤੇ ਸਥਿਤ ਸੀ। ਇਸੇ ਕਾਰਨ ਕਰਕੇ, ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਜ਼ਿਆਦਾਤਰ ਕੋਡਾਂ ਨੂੰ ਕੋਡ ਵਜੋਂ ਨਹੀਂ ਪਛਾਣਦਾ, ਜੋ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਕੁਝ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ। ਅਸੀਂ IDA ਨੂੰ ਦੱਸਦੇ ਹਾਂ ਕਿ ਇਹ ਕੋਡ ਹੈ, ਅਤੇ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ:

ਸਾਰਣੀ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ 0xB144 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ। sub_494C ਵਿੱਚ ਕੀ ਹੈ?

LR ਰਜਿਸਟਰ ਵਿੱਚ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਦੱਸੇ ਗਏ ਟੇਬਲ (0xB144) ਦਾ ਪਤਾ ਮਿਲਦਾ ਹੈ। R0 ਵਿੱਚ - ਇਸ ਸਾਰਣੀ ਵਿੱਚ ਸੂਚਕਾਂਕ। ਭਾਵ, ਮੁੱਲ ਨੂੰ ਸਾਰਣੀ ਤੋਂ ਲਿਆ ਜਾਂਦਾ ਹੈ, LR ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਨਤੀਜਾ ਹੁੰਦਾ ਹੈ
ਜਾਣ ਲਈ ਪਤਾ. ਆਉ ਇਸਦੀ ਗਣਨਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ: 0xB144 + [0xB144 + 8* 4] = 0xB144 + 0x120 = 0xB264। ਅਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਪਤੇ 'ਤੇ ਜਾਂਦੇ ਹਾਂ ਅਤੇ ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਕੁਝ ਉਪਯੋਗੀ ਨਿਰਦੇਸ਼ ਦੇਖਦੇ ਹਾਂ ਅਤੇ ਦੁਬਾਰਾ 0xB140 'ਤੇ ਜਾਂਦੇ ਹਾਂ:

ਹੁਣ ਟੇਬਲ ਤੋਂ ਇੰਡੈਕਸ 0x20 ਦੇ ਨਾਲ ਆਫਸੈੱਟ 'ਤੇ ਇੱਕ ਤਬਦੀਲੀ ਹੋਵੇਗੀ।

ਸਾਰਣੀ ਦੇ ਆਕਾਰ ਦੁਆਰਾ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ, ਕੋਡ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਅਜਿਹੇ ਪਰਿਵਰਤਨ ਹੋਣਗੇ. ਸਵਾਲ ਇਹ ਉੱਠਦਾ ਹੈ ਕਿ ਕੀ ਪਤਿਆਂ ਦੀ ਦਸਤੀ ਗਣਨਾ ਕੀਤੇ ਬਿਨਾਂ, ਇਸ ਨਾਲ ਹੋਰ ਆਪਣੇ ਆਪ ਹੀ ਨਜਿੱਠਣਾ ਸੰਭਵ ਹੈ ਜਾਂ ਨਹੀਂ। ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ IDA ਵਿੱਚ ਕੋਡ ਪੈਚ ਕਰਨ ਦੀ ਯੋਗਤਾ ਸਾਡੀ ਸਹਾਇਤਾ ਲਈ ਆਉਂਦੀ ਹੈ:

def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 2
if get_wide_word(ea1) == 0xbf00: #NOP
ea1 += 2
if get_operand_type(ea1, 0) == 1 and get_operand_value(ea1, 0) == 0 and get_operand_type(ea1, 1) == 2:
index = get_wide_dword(get_operand_value(ea1, 1))
print "index =", hex(index)
ea1 += 2
if get_operand_type(ea1, 0) == 7:
table = get_operand_value(ea1, 0) + 4
elif get_operand_type(ea1, 1) == 2:
table = get_operand_value(ea1, 1) + 4
else:
print "Wrong operand type on", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
table = None
if table is None:
print "Unable to find table"
else:
print "table =", hex(table)
offset = get_wide_dword(table + (index << 2))
put_unconditional_branch(ea, table + offset)
else:
print "Unknown code", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
print "Unable to detect first instruction"

ਕਰਸਰ ਨੂੰ ਲਾਈਨ 0xB26A 'ਤੇ ਰੱਖੋ, ਸਕ੍ਰਿਪਟ ਚਲਾਓ ਅਤੇ 0xB4B0 ਵਿੱਚ ਤਬਦੀਲੀ ਵੇਖੋ:

IDA ਨੇ ਦੁਬਾਰਾ ਇਸ ਖੇਤਰ ਨੂੰ ਕੋਡ ਵਜੋਂ ਮਾਨਤਾ ਨਹੀਂ ਦਿੱਤੀ। ਅਸੀਂ ਉਸਦੀ ਮਦਦ ਕਰਦੇ ਹਾਂ ਅਤੇ ਉੱਥੇ ਇੱਕ ਹੋਰ ਡਿਜ਼ਾਈਨ ਦੇਖਦੇ ਹਾਂ:

BLX ਤੋਂ ਬਾਅਦ ਦੀਆਂ ਹਦਾਇਤਾਂ ਜ਼ਿਆਦਾ ਅਰਥ ਨਹੀਂ ਰੱਖਦੀਆਂ, ਇਹ ਕਿਸੇ ਕਿਸਮ ਦੇ ਵਿਸਥਾਪਨ ਵਰਗਾ ਹੈ। ਆਉ ਸਬ_4964 ਨੂੰ ਵੇਖੀਏ:

ਅਤੇ ਅਸਲ ਵਿੱਚ, ਇੱਥੇ LR ਵਿੱਚ ਪਏ ਪਤੇ 'ਤੇ ਇੱਕ ਡਵਰਡ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਪਤੇ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਨਤੀਜੇ ਵਾਲੇ ਪਤੇ 'ਤੇ ਮੁੱਲ ਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਸਟੈਕ 'ਤੇ ਪਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਨਾਲ ਹੀ, 4 ਨੂੰ LR ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਫੰਕਸ਼ਨ ਤੋਂ ਵਾਪਸ ਆਉਣ ਤੋਂ ਬਾਅਦ, ਇਹੋ ਆਫਸੈੱਟ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇ। ਜਿਸ ਤੋਂ ਬਾਅਦ POP {R1} ਕਮਾਂਡ ਸਟੈਕ ਤੋਂ ਨਤੀਜਾ ਮੁੱਲ ਲੈਂਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ ਕਿ ਪਤੇ 0xB4BA + 0xEA = 0xB5A4 'ਤੇ ਕੀ ਸਥਿਤ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਐਡਰੈੱਸ ਟੇਬਲ ਦੇ ਸਮਾਨ ਕੁਝ ਦੇਖੋਗੇ:

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

patches = {}
patches[0] = (0x00, 0xbf, 0x01, 0x48, 0x00, 0x68, 0x02, 0xe0)
patches[1] = (0x00, 0xbf, 0x01, 0x49, 0x09, 0x68, 0x02, 0xe0)
patches[2] = (0x00, 0xbf, 0x01, 0x4a, 0x12, 0x68, 0x02, 0xe0)
patches[3] = (0x00, 0xbf, 0x01, 0x4b, 0x1b, 0x68, 0x02, 0xe0)
patches[4] = (0x00, 0xbf, 0x01, 0x4c, 0x24, 0x68, 0x02, 0xe0)
patches[5] = (0x00, 0xbf, 0x01, 0x4d, 0x2d, 0x68, 0x02, 0xe0)
patches[8] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x80, 0xd8, 0xf8, 0x00, 0x80, 0x01, 0xe0)
patches[9] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x90, 0xd9, 0xf8, 0x00, 0x90, 0x01, 0xe0)
patches[10] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xa0, 0xda, 0xf8, 0x00, 0xa0, 0x01, 0xe0)
patches[11] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xb0, 0xdb, 0xf8, 0x00, 0xb0, 0x01, 0xe0)
ea = here()
if (get_wide_word(ea) == 0xb082 #SUB SP, SP, #8
and get_wide_word(ea + 2) == 0xb503): #PUSH {R0,R1,LR}
if get_operand_type(ea + 4, 0) == 7:
pop = get_bytes(ea + 12, 4, 0)
if pop[1] == 'xbc':
register = -1
r = get_wide_byte(ea + 12)
for i in range(8):
if r == (1 << i):
register = i
break
if register == -1:
print "Unable to detect register"
else:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
if ea % 4 != 0:
ea += 2
patch_dword(ea, address)
elif pop[:3] == 'x5dxf8x04':
register = ord(pop[3]) >> 4
if register in patches:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
patch_dword(ea, address)
else:
print "POP instruction not found"
else:
print "Wrong operand type on +4:", get_operand_type(ea + 4, 0)
else:
print "Unable to detect first instructions"

ਅਸੀਂ ਕਰਸਰ ਨੂੰ ਉਸ ਢਾਂਚੇ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਰੱਖਦੇ ਹਾਂ ਜਿਸ ਨੂੰ ਅਸੀਂ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹਾਂ - 0xB4B2 - ਅਤੇ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਓ:

ਪਹਿਲਾਂ ਹੀ ਦੱਸੇ ਗਏ ਢਾਂਚਿਆਂ ਤੋਂ ਇਲਾਵਾ, ਕੋਡ ਵਿੱਚ ਇਹ ਵੀ ਸ਼ਾਮਲ ਹਨ:

ਜਿਵੇਂ ਕਿ ਪਿਛਲੇ ਕੇਸ ਵਿੱਚ, BLX ਨਿਰਦੇਸ਼ ਦੇ ਬਾਅਦ ਇੱਕ ਔਫਸੈੱਟ ਹੈ:

ਅਸੀਂ ਔਫਸੈੱਟ ਨੂੰ LR ਤੋਂ ਪਤੇ 'ਤੇ ਲੈਂਦੇ ਹਾਂ, ਇਸਨੂੰ LR ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ ਅਤੇ ਉੱਥੇ ਜਾਂਦੇ ਹਾਂ। 0x72044 + 0xC = 0x72050। ਇਸ ਡਿਜ਼ਾਈਨ ਲਈ ਸਕ੍ਰਿਪਟ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ:

def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 6
if get_wide_word(ea + 2) == 0xbf00: #NOP
ea1 += 2
offset = get_wide_dword(ea1)
put_unconditional_branch(ea, (ea1 + offset) & 0xffffffff)
else:
print "Unable to detect first instruction"

ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਨਤੀਜਾ:

ਇੱਕ ਵਾਰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਸਭ ਕੁਝ ਪੈਚ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ IDA ਨੂੰ ਇਸਦੀ ਅਸਲ ਸ਼ੁਰੂਆਤ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਸਾਰੇ ਫੰਕਸ਼ਨ ਕੋਡ ਨੂੰ ਇਕੱਠਾ ਕਰੇਗਾ, ਅਤੇ ਇਸ ਨੂੰ HexRays ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੀਕੰਪਾਇਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਡੀਕੋਡਿੰਗ ਸਤਰ

ਅਸੀਂ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਮਸ਼ੀਨ ਕੋਡ ਦੀ ਗੜਬੜ ਨਾਲ ਨਜਿੱਠਣਾ ਸਿੱਖਿਆ ਹੈ libsgmainso-6.4.36.so UC ਬਰਾਊਜ਼ਰ ਤੋਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕੋਡ ਪ੍ਰਾਪਤ ਕੀਤਾ JNI_ਆਨਲੋਡ.

int __fastcall real_JNI_OnLoad(JavaVM *vm)
{
int result; // r0
jclass clazz; // r0 MAPDST
int v4; // r0
JNIEnv *env; // r4
int v6; // [sp-40h] [bp-5Ch]
int v7; // [sp+Ch] [bp-10h]
v7 = *(_DWORD *)off_8AC00;
if ( !vm )
goto LABEL_39;
sub_7C4F4();
env = (JNIEnv *)sub_7C5B0(0);
if ( !env )
goto LABEL_39;
v4 = sub_72CCC();
sub_73634(v4);
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);
if ( clazz
&& (sub_9EE4(),
sub_71D68(env),
sub_E7DC(env) >= 0
&& sub_69D68(env) >= 0
&& sub_197B4(env, clazz) >= 0
&& sub_E240(env, clazz) >= 0
&& sub_B8B0(env, clazz) >= 0
&& sub_5F0F4(env, clazz) >= 0
&& sub_70640(env, clazz) >= 0
&& sub_11F3C(env) >= 0
&& sub_21C3C(env, clazz) >= 0
&& sub_2148C(env, clazz) >= 0
&& sub_210E0(env, clazz) >= 0
&& sub_41B58(env, clazz) >= 0
&& sub_27920(env, clazz) >= 0
&& sub_293E8(env, clazz) >= 0
&& sub_208F4(env, clazz) >= 0) )
{
result = (sub_B7B0(env, clazz) >> 31) | 0x10004;
}
else
{
LABEL_39:
result = -1;
}
return result;
}

ਆਓ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ:

  sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);

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

int __fastcall sub_73E56(unsigned __int8 *in, unsigned __int8 *out, size_t size)
{
int v4; // r6
int v7; // r11
int v8; // r9
int v9; // r4
size_t v10; // r5
int v11; // r0
struc_1 v13; // [sp+0h] [bp-30h]
int v14; // [sp+1Ch] [bp-14h]
int v15; // [sp+20h] [bp-10h]
v4 = 0;
v15 = *(_DWORD *)off_8AC00;
v14 = 0;
v7 = sub_7AF78(17);
v8 = sub_7AF78(size);
if ( !v7 )
{
v9 = 0;
goto LABEL_12;
}
(*(void (__fastcall **)(int, const char *, int))(v7 + 12))(v7, "DcO/lcK+h?m3c*q@", 16);
if ( !v8 )
{
LABEL_9:
v4 = 0;
goto LABEL_10;
}
v4 = 0;
if ( !in )
{
LABEL_10:
v9 = 0;
goto LABEL_11;
}
v9 = 0;
if ( out )
{
memset(out, 0, size);
v10 = size - 1;
(*(void (__fastcall **)(int, unsigned __int8 *, size_t))(v8 + 12))(v8, in, v10);
memset(&v13, 0, 0x14u);
v13.field_4 = 3;
v13.field_10 = v7;
v13.field_14 = v8;
v11 = sub_6115C(&v13, &v14);
v9 = v11;
if ( v11 )
{
if ( *(_DWORD *)(v11 + 4) == v10 )
{
qmemcpy(out, *(const void **)v11, v10);
v4 = *(_DWORD *)(v9 + 4);
}
else
{
v4 = 0;
}
goto LABEL_11;
}
goto LABEL_9;
}
LABEL_11:
sub_7B148(v7);
LABEL_12:
if ( v8 )
sub_7B148(v8);
if ( v9 )
sub_7B148(v9);
return v4;
}

ਫੰਕਸ਼ਨ sub_7AF78 ਨਿਰਧਾਰਤ ਆਕਾਰ ਦੇ ਬਾਈਟ ਐਰੇ ਲਈ ਇੱਕ ਕੰਟੇਨਰ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦਾ ਹੈ (ਅਸੀਂ ਇਹਨਾਂ ਕੰਟੇਨਰਾਂ 'ਤੇ ਵਿਸਥਾਰ ਵਿੱਚ ਨਹੀਂ ਵਿਚਾਰ ਕਰਾਂਗੇ)। ਇੱਥੇ ਦੋ ਅਜਿਹੇ ਡੱਬੇ ਬਣਾਏ ਗਏ ਹਨ: ਇੱਕ ਲਾਈਨ ਰੱਖਦਾ ਹੈ "DcO/lcK+h?m3c*q@" (ਇਹ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ ਆਸਾਨ ਹੈ ਕਿ ਇਹ ਇੱਕ ਕੁੰਜੀ ਹੈ), ਦੂਜੇ ਵਿੱਚ ਐਨਕ੍ਰਿਪਟਡ ਡੇਟਾ ਸ਼ਾਮਲ ਹੈ। ਅੱਗੇ, ਦੋਵੇਂ ਵਸਤੂਆਂ ਨੂੰ ਇੱਕ ਖਾਸ ਢਾਂਚੇ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ sub_6115C. ਚਲੋ ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਮੁੱਲ 3 ਦੇ ਨਾਲ ਇੱਕ ਖੇਤਰ ਨੂੰ ਵੀ ਚਿੰਨ੍ਹਿਤ ਕਰੀਏ। ਆਓ ਦੇਖੀਏ ਕਿ ਇਸ ਢਾਂਚੇ ਦਾ ਅੱਗੇ ਕੀ ਹੁੰਦਾ ਹੈ।

int __fastcall sub_611B4(struc_1 *a1, _DWORD *a2)
{
int v3; // lr
unsigned int v4; // r1
int v5; // r0
int v6; // r1
int result; // r0
int v8; // r0
*a2 = 820000;
if ( a1 )
{
v3 = a1->field_14;
if ( v3 )
{
v4 = a1->field_4;
if ( v4 < 0x19 )
{
switch ( v4 )
{
case 0u:
v8 = sub_6419C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 3u:
v8 = sub_6364C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 0x10u:
case 0x11u:
case 0x12u:
v8 = sub_612F4(
a1->field_0,
v4,
*(_QWORD *)&a1->field_8,
*(_QWORD *)&a1->field_8 >> 32,
a1->field_10,
v3,
a2);
goto LABEL_17;
case 0x14u:
v8 = sub_63A28(a1->field_0, v3);
goto LABEL_17;
case 0x15u:
sub_61A60(a1->field_0, v3, a2);
return result;
case 0x16u:
v8 = sub_62440(a1->field_14);
goto LABEL_17;
case 0x17u:
v8 = sub_6226C(a1->field_10, v3);
goto LABEL_17;
case 0x18u:
v8 = sub_63530(a1->field_14);
LABEL_17:
v6 = 0;
if ( v8 )
{
*a2 = 0;
v6 = v8;
}
return v6;
default:
LOWORD(v5) = 28032;
goto LABEL_5;
}
}
}
}
LOWORD(v5) = -27504;
LABEL_5:
HIWORD(v5) = 13;
v6 = 0;
*a2 = v5;
return v6;
}

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

ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਲਗੋਰਿਦਮ ਅਤੇ ਇੱਕ ਕੁੰਜੀ ਹੈ। ਆਉ ਕਲਾਸ ਦੇ ਨਾਮ ਨੂੰ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਇੱਥੇ ਕੀ ਹੋਇਆ ਹੈ: com/taobao/wireless/security/adapter/JNICLlibrary. ਬਹੁਤ ਵਧੀਆ! ਅਸੀਂ ਸਹੀ ਰਸਤੇ 'ਤੇ ਹਾਂ।

ਹੁਕਮ ਦਾ ਰੁੱਖ

ਹੁਣ ਸਾਨੂੰ ਇੱਕ ਚੁਣੌਤੀ ਲੱਭਣ ਦੀ ਲੋੜ ਹੈ ਰਜਿਸਟਰ ਨੇਟਿਵ, ਜੋ ਸਾਨੂੰ ਫੰਕਸ਼ਨ ਵੱਲ ਸੰਕੇਤ ਕਰੇਗਾ doCommandNative. ਆਉ ਇਸ ਤੋਂ ਬੁਲਾਏ ਗਏ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵੇਖੀਏ JNI_ਆਨਲੋਡ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਵਿੱਚ ਲੱਭਦੇ ਹਾਂ sub_B7B0:

int __fastcall sub_B7F6(JNIEnv *env, jclass clazz)
{
char signature[41]; // [sp+7h] [bp-55h]
char name[16]; // [sp+30h] [bp-2Ch]
JNINativeMethod method; // [sp+40h] [bp-1Ch]
int v8; // [sp+4Ch] [bp-10h]
v8 = *(_DWORD *)off_8AC00;
decryptString((unsigned __int8 *)&unk_83ED9, (unsigned __int8 *)name, 0x10u);// doCommandNative
decryptString((unsigned __int8 *)&unk_83EEA, (unsigned __int8 *)signature, 0x29u);// (I[Ljava/lang/Object;)Ljava/lang/Object;
method.name = name;
method.signature = signature;
method.fnPtr = sub_B69C;
return ((int (__fastcall *)(JNIEnv *, jclass, JNINativeMethod *, int))(*env)->RegisterNatives)(env, clazz, &method, 1) >> 31;
}

ਅਤੇ ਅਸਲ ਵਿੱਚ, ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਦੇਸੀ ਢੰਗ ਇੱਥੇ ਰਜਿਸਟਰ ਕੀਤਾ ਗਿਆ ਹੈ doCommandNative. ਹੁਣ ਸਾਨੂੰ ਉਸਦਾ ਪਤਾ ਪਤਾ ਹੈ। ਆਓ ਦੇਖੀਏ ਕਿ ਉਹ ਕੀ ਕਰਦਾ ਹੈ।

int __fastcall doCommandNative(JNIEnv *env, jobject obj, int command, jarray args)
{
int v5; // r5
struc_2 *a5; // r6
int v9; // r1
int v11; // [sp+Ch] [bp-14h]
int v12; // [sp+10h] [bp-10h]
v5 = 0;
v12 = *(_DWORD *)off_8AC00;
v11 = 0;
a5 = (struc_2 *)malloc(0x14u);
if ( a5 )
{
a5->field_0 = 0;
a5->field_4 = 0;
a5->field_8 = 0;
a5->field_C = 0;
v9 = command % 10000 / 100;
a5->field_0 = command / 10000;
a5->field_4 = v9;
a5->field_8 = command % 100;
a5->field_C = env;
a5->field_10 = args;
v5 = sub_9D60(command / 10000, v9, command % 100, 1, (int)a5, &v11);
}
free(a5);
if ( !v5 && v11 )
sub_7CF34(env, v11, &byte_83ED7);
return v5;
}

ਨਾਮ ਦੁਆਰਾ ਤੁਸੀਂ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹੋ ਕਿ ਇੱਥੇ ਉਹਨਾਂ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਦਾ ਪ੍ਰਵੇਸ਼ ਬਿੰਦੂ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੇ ਮੂਲ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਅਸੀਂ ਫੰਕਸ਼ਨ ਨੰਬਰ 10601 ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ।

ਤੁਸੀਂ ਕੋਡ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕਮਾਂਡ ਨੰਬਰ ਤਿੰਨ ਨੰਬਰ ਪੈਦਾ ਕਰਦਾ ਹੈ: ਕਮਾਂਡ/10000, ਕਮਾਂਡ % 10000 / 100 и ਕਮਾਂਡ % 10, ਭਾਵ, ਸਾਡੇ ਕੇਸ ਵਿੱਚ, 1, 6 ਅਤੇ 1. ਇਹ ਤਿੰਨ ਸੰਖਿਆਵਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਇੱਕ ਸੰਕੇਤਕ JNIEnv ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਇੱਕ ਢਾਂਚੇ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪ੍ਰਾਪਤ ਕੀਤੇ ਤਿੰਨ ਨੰਬਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ (ਆਓ ਉਹਨਾਂ ਨੂੰ N1, N2 ਅਤੇ N3 ਦਰਸਾਉਂਦੇ ਹਾਂ), ਇੱਕ ਕਮਾਂਡ ਟ੍ਰੀ ਬਣਾਇਆ ਗਿਆ ਹੈ।

ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ:

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

ਹੋਰ ਉਲਝਣ

ਸਾਨੂੰ ਫੰਕਸ਼ਨ ਦਾ ਪਤਾ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ ਜਿਸ ਨੂੰ ਟ੍ਰੈਫਿਕ ਨੂੰ ਡੀਕ੍ਰਿਪਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ: 0x5F1AC। ਪਰ ਖੁਸ਼ ਹੋਣਾ ਬਹੁਤ ਜਲਦੀ ਹੈ: UC ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਡਿਵੈਲਪਰਾਂ ਨੇ ਸਾਡੇ ਲਈ ਇੱਕ ਹੋਰ ਹੈਰਾਨੀ ਤਿਆਰ ਕੀਤੀ ਹੈ।

ਜਾਵਾ ਕੋਡ ਵਿੱਚ ਬਣਾਏ ਗਏ ਐਰੇ ਤੋਂ ਪੈਰਾਮੀਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ
ਪਤੇ 0x4D070 'ਤੇ ਫੰਕਸ਼ਨ ਲਈ। ਅਤੇ ਇੱਥੇ ਇੱਕ ਹੋਰ ਕਿਸਮ ਦਾ ਕੋਡ ਗੁੰਝਲਦਾਰ ਸਾਡੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ।

ਅਸੀਂ R7 ਅਤੇ R4 ਵਿੱਚ ਦੋ ਸੂਚਕਾਂਕ ਪਾਉਂਦੇ ਹਾਂ:

ਅਸੀਂ ਪਹਿਲੇ ਸੂਚਕਾਂਕ ਨੂੰ R11 ਵਿੱਚ ਸ਼ਿਫਟ ਕਰਦੇ ਹਾਂ:

ਇੱਕ ਸਾਰਣੀ ਤੋਂ ਇੱਕ ਪਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਇੱਕ ਸੂਚਕਾਂਕ ਦੀ ਵਰਤੋਂ ਕਰੋ:

ਪਹਿਲੇ ਪਤੇ 'ਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਦੂਜਾ ਸੂਚਕਾਂਕ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ R4 ਵਿੱਚ ਹੈ. ਸਾਰਣੀ ਵਿੱਚ 230 ਤੱਤ ਹਨ।

ਇਸ ਬਾਰੇ ਕੀ ਕਰਨਾ ਹੈ? ਤੁਸੀਂ IDA ਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਇੱਕ ਸਵਿੱਚ ਹੈ: ਸੰਪਾਦਿਤ ਕਰੋ -> ਹੋਰ -> ਸਵਿੱਚ ਮੁਹਾਵਰਾ ਦਿਓ।

ਨਤੀਜਾ ਕੋਡ ਡਰਾਉਣਾ ਹੈ. ਪਰ, ਇਸਦੇ ਜੰਗਲ ਵਿੱਚ ਆਪਣਾ ਰਸਤਾ ਬਣਾਉਂਦੇ ਹੋਏ, ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਦੇਖ ਸਕਦੇ ਹੋ ਜੋ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਜਾਣੂ ਹੈ sub_6115C:

ਇੱਕ ਸਵਿੱਚ ਸੀ ਜਿਸ ਵਿੱਚ ਕੇਸ 3 ਵਿੱਚ RC4 ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਡੀਕ੍ਰਿਪਸ਼ਨ ਸੀ। ਅਤੇ ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਢਾਂਚਾ ਪਾਸ ਕੀਤੇ ਪੈਰਾਮੀਟਰਾਂ ਤੋਂ ਭਰਿਆ ਜਾਂਦਾ ਹੈ doCommandNative. ਆਓ ਯਾਦ ਕਰੀਏ ਕਿ ਸਾਡੇ ਕੋਲ ਉੱਥੇ ਕੀ ਸੀ magicInt ਮੁੱਲ ਦੇ ਨਾਲ 16. ਅਸੀਂ ਸੰਬੰਧਿਤ ਕੇਸ ਨੂੰ ਦੇਖਦੇ ਹਾਂ - ਅਤੇ ਕਈ ਪਰਿਵਰਤਨਾਂ ਤੋਂ ਬਾਅਦ ਸਾਨੂੰ ਉਹ ਕੋਡ ਮਿਲਦਾ ਹੈ ਜਿਸ ਦੁਆਰਾ ਐਲਗੋਰਿਦਮ ਦੀ ਪਛਾਣ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਇਹ AES ਹੈ!

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

ਪੈਚ

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

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

ਪਹਿਲਾ ਭਾਗ:

ARM ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ, ਪਹਿਲੇ ਚਾਰ ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਰਜਿਸਟਰ R0-R3 ਦੁਆਰਾ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਬਾਕੀ, ਜੇਕਰ ਕੋਈ ਹੈ, ਸਟੈਕ ਦੁਆਰਾ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। LR ਰਜਿਸਟਰ ਵਿੱਚ ਵਾਪਸੀ ਦਾ ਪਤਾ ਹੁੰਦਾ ਹੈ। ਇਸ ਸਭ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਫੰਕਸ਼ਨ ਇਸ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਡੰਪ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕੰਮ ਕਰ ਸਕੇ। ਸਾਨੂੰ ਉਹਨਾਂ ਸਾਰੇ ਰਜਿਸਟਰਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਹੈ ਜੋ ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਵਰਤਾਂਗੇ, ਇਸ ਲਈ ਅਸੀਂ PUSH.W {R0-R10,LR} ਕਰਦੇ ਹਾਂ। R7 ਵਿੱਚ ਸਾਨੂੰ ਸਟੈਕ ਰਾਹੀਂ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਸੂਚੀ ਦਾ ਪਤਾ ਮਿਲਦਾ ਹੈ।

ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਫੋਪੇਨ ਚਲੋ ਫਾਈਲ ਖੋਲ੍ਹੀਏ /data/local/tmp/aes "ab" ਮੋਡ ਵਿੱਚ
ਭਾਵ ਜੋੜਨ ਲਈ। R0 ਵਿੱਚ ਅਸੀਂ ਫਾਈਲ ਨਾਮ ਦਾ ਪਤਾ ਲੋਡ ਕਰਦੇ ਹਾਂ, R1 ਵਿੱਚ - ਮੋਡ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀ ਲਾਈਨ ਦਾ ਪਤਾ। ਅਤੇ ਇੱਥੇ ਗਾਰਬੇਜ ਕੋਡ ਖਤਮ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਅਗਲੇ ਫੰਕਸ਼ਨ 'ਤੇ ਜਾਂਦੇ ਹਾਂ। ਇਸ ਨੂੰ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖਣ ਲਈ, ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਕੂੜੇ ਨੂੰ ਬਾਈਪਾਸ ਕਰਦੇ ਹੋਏ, ਫੰਕਸ਼ਨ ਦੇ ਅਸਲ ਕੋਡ ਵਿੱਚ ਤਬਦੀਲੀ ਪਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਕੂੜੇ ਦੀ ਬਜਾਏ ਅਸੀਂ ਪੈਚ ਦੀ ਨਿਰੰਤਰਤਾ ਜੋੜਦੇ ਹਾਂ।

ਕਾਲ ਕਰ ਰਿਹਾ ਹੈ ਫੋਪੇਨ.

ਫੰਕਸ਼ਨ ਦੇ ਪਹਿਲੇ ਤਿੰਨ ਪੈਰਾਮੀਟਰ AES ਕਿਸਮ ਹੈ ਇੰਟ. ਕਿਉਂਕਿ ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਰਜਿਸਟਰਾਂ ਨੂੰ ਸਟੈਕ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਹੈ, ਅਸੀਂ ਫੰਕਸ਼ਨ ਨੂੰ ਸਿਰਫ਼ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ ਲਿਖੋ ਸਟੈਕ 'ਤੇ ਉਨ੍ਹਾਂ ਦੇ ਪਤੇ।

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

ਅੰਤ ਵਿੱਚ, ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰੋ, ਰਜਿਸਟਰਾਂ ਨੂੰ ਰੀਸਟੋਰ ਕਰੋ ਅਤੇ ਨਿਯੰਤਰਣ ਨੂੰ ਅਸਲ ਫੰਕਸ਼ਨ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰੋ AES.

ਅਸੀਂ ਇੱਕ ਪੈਚ ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਇੱਕ APK ਇਕੱਠਾ ਕਰਦੇ ਹਾਂ, ਇਸ 'ਤੇ ਦਸਤਖਤ ਕਰਦੇ ਹਾਂ, ਇਸਨੂੰ ਡਿਵਾਈਸ/ਇਮੂਲੇਟਰ 'ਤੇ ਅੱਪਲੋਡ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਇਸਨੂੰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਸਾਡਾ ਡੰਪ ਬਣਾਇਆ ਜਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਉੱਥੇ ਬਹੁਤ ਸਾਰਾ ਡਾਟਾ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ. ਬ੍ਰਾਉਜ਼ਰ ਨਾ ਸਿਰਫ ਟ੍ਰੈਫਿਕ ਲਈ ਏਨਕ੍ਰਿਪਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਾਰੇ ਏਨਕ੍ਰਿਪਸ਼ਨ ਪ੍ਰਸ਼ਨ ਵਿੱਚ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਜਾਂਦੇ ਹਨ। ਪਰ ਕਿਸੇ ਕਾਰਨ ਲੋੜੀਂਦਾ ਡੇਟਾ ਉਥੇ ਨਹੀਂ ਹੈ, ਅਤੇ ਲੋੜੀਂਦੀ ਬੇਨਤੀ ਆਵਾਜਾਈ ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦੇ ਰਹੀ ਹੈ. ਜਦੋਂ ਤੱਕ UC ਬ੍ਰਾਊਜ਼ਰ ਜ਼ਰੂਰੀ ਬੇਨਤੀ ਕਰਨ ਲਈ ਤਿਆਰ ਨਹੀਂ ਹੁੰਦਾ ਉਦੋਂ ਤੱਕ ਇੰਤਜ਼ਾਰ ਨਾ ਕਰਨ ਲਈ, ਆਓ ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਹੋਏ ਸਰਵਰ ਤੋਂ ਐਨਕ੍ਰਿਪਟਡ ਜਵਾਬ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਪੈਚ ਕਰਦੇ ਹਾਂ: ਮੁੱਖ ਗਤੀਵਿਧੀ ਦੇ onCreate ਵਿੱਚ ਡੀਕ੍ਰਿਪਸ਼ਨ ਸ਼ਾਮਲ ਕਰੋ।

    const/16 v1, 0x62
new-array v1, v1, [B
fill-array-data v1, :encrypted_data
const/16 v0, 0x1f
invoke-static {v0, v1}, Lcom/uc/browser/core/d/c/g;->j(I[B)[B
move-result-object v1
array-length v2, v1
invoke-static {v2}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
move-result-object v2
const-string v0, "ololo"
invoke-static {v0, v2}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I

ਅਸੀਂ ਅਸੈਂਬਲ ਕਰਦੇ ਹਾਂ, ਸਾਈਨ ਕਰਦੇ ਹਾਂ, ਸਥਾਪਿਤ ਕਰਦੇ ਹਾਂ, ਲਾਂਚ ਕਰਦੇ ਹਾਂ। ਸਾਨੂੰ ਇੱਕ NullPointerException ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਵਿਧੀ ਨਲ ਵਾਪਸ ਆਉਂਦੀ ਹੈ।

ਕੋਡ ਦੇ ਹੋਰ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਦੌਰਾਨ, ਇੱਕ ਫੰਕਸ਼ਨ ਖੋਜਿਆ ਗਿਆ ਸੀ ਜੋ ਦਿਲਚਸਪ ਲਾਈਨਾਂ ਨੂੰ ਸਮਝਦਾ ਹੈ: “META-INF/” ਅਤੇ “.RSA”। ਇੰਝ ਜਾਪਦਾ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਆਪਣੇ ਸਰਟੀਫਿਕੇਟ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਰਹੀ ਹੈ। ਜਾਂ ਇਸ ਤੋਂ ਕੁੰਜੀਆਂ ਵੀ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਮੈਂ ਅਸਲ ਵਿੱਚ ਸਰਟੀਫਿਕੇਟ ਦੇ ਨਾਲ ਕੀ ਹੋ ਰਿਹਾ ਹੈ ਇਸ ਨਾਲ ਨਜਿੱਠਣਾ ਨਹੀਂ ਚਾਹੁੰਦਾ, ਇਸ ਲਈ ਅਸੀਂ ਇਸਨੂੰ ਸਹੀ ਸਰਟੀਫਿਕੇਟ ਦੇਵਾਂਗੇ। ਚਲੋ ਏਨਕ੍ਰਿਪਟਡ ਲਾਈਨ ਨੂੰ ਪੈਚ ਕਰੀਏ ਤਾਂ ਕਿ "META-INF/" ਦੀ ਬਜਾਏ ਸਾਨੂੰ "BLABLINF/" ਪ੍ਰਾਪਤ ਹੋਵੇ, ਏਪੀਕੇ ਵਿੱਚ ਉਸ ਨਾਮ ਨਾਲ ਇੱਕ ਫੋਲਡਰ ਬਣਾਓ ਅਤੇ ਉੱਥੇ ਸਕਵਾਇਰਲ ਬ੍ਰਾਊਜ਼ਰ ਸਰਟੀਫਿਕੇਟ ਸ਼ਾਮਲ ਕਰੋ।

ਅਸੀਂ ਅਸੈਂਬਲ ਕਰਦੇ ਹਾਂ, ਸਾਈਨ ਕਰਦੇ ਹਾਂ, ਸਥਾਪਿਤ ਕਰਦੇ ਹਾਂ, ਲਾਂਚ ਕਰਦੇ ਹਾਂ। ਬਿੰਗੋ! ਸਾਡੇ ਕੋਲ ਕੁੰਜੀ ਹੈ!

ਐੱਮ.ਆਈ.ਟੀ.ਐੱਮ

ਸਾਨੂੰ ਕੁੰਜੀ ਦੇ ਬਰਾਬਰ ਇੱਕ ਕੁੰਜੀ ਅਤੇ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਵੈਕਟਰ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ। ਆਉ CBC ਮੋਡ ਵਿੱਚ ਸਰਵਰ ਜਵਾਬ ਨੂੰ ਡੀਕ੍ਰਿਪਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।

ਅਸੀਂ ਆਰਕਾਈਵ URL ਦੇਖਦੇ ਹਾਂ, ਜੋ ਕਿ MD5 ਵਰਗਾ ਹੈ, "ਐਕਸਟ੍ਰੈਕਟ_ਅਨਜ਼ਿਪਸਾਈਜ਼" ਅਤੇ ਇੱਕ ਨੰਬਰ। ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ: ਆਰਕਾਈਵ ਦਾ MD5 ਇੱਕੋ ਜਿਹਾ ਹੈ, ਅਨਪੈਕ ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਆਕਾਰ ਇੱਕੋ ਜਿਹਾ ਹੈ। ਅਸੀਂ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਪੈਚ ਕਰਨ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਾਂ। ਇਹ ਦਿਖਾਉਣ ਲਈ ਕਿ ਸਾਡੀ ਪੈਚ ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀ ਲੋਡ ਹੋ ਗਈ ਹੈ, ਅਸੀਂ "PWNED!" ਟੈਕਸਟ ਦੇ ਨਾਲ ਇੱਕ SMS ਬਣਾਉਣ ਲਈ ਇੱਕ ਇਰਾਦਾ ਲਾਂਚ ਕਰਾਂਗੇ। ਅਸੀਂ ਸਰਵਰ ਤੋਂ ਦੋ ਜਵਾਬਾਂ ਨੂੰ ਬਦਲਾਂਗੇ: puds.ucweb.com/upgrade/index.xhtml ਅਤੇ ਪੁਰਾਲੇਖ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ. ਪਹਿਲੇ ਵਿੱਚ ਅਸੀਂ MD5 ਨੂੰ ਬਦਲਦੇ ਹਾਂ (ਪੈਕ ਕਰਨ ਤੋਂ ਬਾਅਦ ਆਕਾਰ ਨਹੀਂ ਬਦਲਦਾ), ਦੂਜੇ ਵਿੱਚ ਅਸੀਂ ਪੈਚ ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ ਪੁਰਾਲੇਖ ਦਿੰਦੇ ਹਾਂ।

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

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

ਅਸੀਂ ਆਰਕਾਈਵ ਦੇ ਆਕਾਰ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਦੇ ਹਾਂ... ਅਤੇ - ਜਿੱਤ! 🙂 ਨਤੀਜਾ ਵੀਡੀਓ ਵਿੱਚ ਹੈ।

https://www.youtube.com/watch?v=Nfns7uH03J8

ਨਤੀਜੇ ਅਤੇ ਵਿਕਾਸਕਾਰ ਪ੍ਰਤੀਕਰਮ

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

ਅਸੀਂ UC ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਡਿਵੈਲਪਰਾਂ ਨਾਲ ਸੰਪਰਕ ਕੀਤਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਾਡੇ ਦੁਆਰਾ ਪਾਈ ਗਈ ਸਮੱਸਿਆ ਬਾਰੇ ਜਾਣੂ ਕਰਵਾਇਆ, ਕਮਜ਼ੋਰੀ ਅਤੇ ਇਸਦੇ ਖਤਰੇ ਨੂੰ ਦਰਸਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਪਰ ਉਹਨਾਂ ਨੇ ਸਾਡੇ ਨਾਲ ਕੋਈ ਗੱਲ ਨਹੀਂ ਕੀਤੀ। ਇਸ ਦੌਰਾਨ, ਬ੍ਰਾਊਜ਼ਰ ਨੇ ਆਪਣੀ ਖਤਰਨਾਕ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਾਦੀ ਨਜ਼ਰ ਵਿੱਚ ਦਿਖਾਉਣਾ ਜਾਰੀ ਰੱਖਿਆ। ਪਰ ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਕਮਜ਼ੋਰੀ ਦੇ ਵੇਰਵਿਆਂ ਦਾ ਖੁਲਾਸਾ ਕਰ ਦਿੱਤਾ, ਤਾਂ ਇਸ ਨੂੰ ਪਹਿਲਾਂ ਵਾਂਗ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਸੀ। 27 ਮਾਰਚ ਸੀ
UC ਬਰਾਊਜ਼ਰ 12.10.9.1193 ਦਾ ਇੱਕ ਨਵਾਂ ਸੰਸਕਰਣ ਜਾਰੀ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਨੇ HTTPS ਦੁਆਰਾ ਸਰਵਰ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਸੀ: puds.ucweb.com/upgrade/index.xhtml.

ਇਸ ਤੋਂ ਇਲਾਵਾ, "ਫਿਕਸ" ਤੋਂ ਬਾਅਦ ਅਤੇ ਇਸ ਲੇਖ ਨੂੰ ਲਿਖਣ ਦੇ ਸਮੇਂ ਤੱਕ, ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇੱਕ PDF ਖੋਲ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਦੇ ਨਤੀਜੇ ਵਜੋਂ "ਓਹ, ਕੁਝ ਗਲਤ ਹੋ ਗਿਆ!" ਟੈਕਸਟ ਦੇ ਨਾਲ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਆਇਆ। ਇੱਕ PDF ਨੂੰ ਖੋਲ੍ਹਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਗਈ ਸੀ, ਪਰ ਇੱਕ ਬੇਨਤੀ ਕੀਤੀ ਗਈ ਸੀ ਜਦੋਂ ਬ੍ਰਾਊਜ਼ਰ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਸੀ, ਜੋ Google Play ਨਿਯਮਾਂ ਦੀ ਉਲੰਘਣਾ ਵਿੱਚ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਕੋਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਨਿਰੰਤਰ ਸਮਰੱਥਾ ਵੱਲ ਸੰਕੇਤ ਕਰਦਾ ਹੈ।

ਸਰੋਤ: www.habr.com