OVO v3.139.0 - VosWrapperBase.java 源代码

package vkey.android.vos;

import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.Signature;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.util.Base64;
import com.vkey.vos.vslogger.LogLevel;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import o.i.b02;
import o.i.j;
import o.i.ko5;
import o.i.pq0;
import o.i.z42;
import o.i.zz1;
import ovo.id.wallet.checkout.core.data.entity.response.CheckoutComponentResponse;
import zendesk.chat.WebSocket;

public class VosWrapperBase {
    protected static Context ctx;
    private static vkey.android.vos.a.b f;
    private static TTHelper helper;
    private static final char[] hexArray;

    public static class TTHelper {
        private Context context;
        private Date endTime;
        private byte[] requestBuffer;
        private int requestSize;
        private String result = null;
        private int statusCode = 0;
        private int timeoutSeconds;
        private String url;
        private String userId;
        private String userPassword;

        public class StrictTrustManager implements X509TrustManager {
            public StrictTrustManager(String str) {
            }

            @Override
            public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }

            public StrictTrustManager(String str, String str2, int i) {
            }
        }

        public class TLSSocketFactory extends SSLSocketFactory {
            private final String TAG;
            private SSLSocketFactory internalSSLSocketFactory;
            private KeyManager[] mKeyManagers;
            private SSLContext mSslContext;

            public TLSSocketFactory() {
                this.TAG = TLSSocketFactory.class.getSimpleName();
                this.mKeyManagers = null;
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                this.mSslContext = sSLContext;
                sSLContext.init(null, new TrustManager[]{TTHelper.this.new StrictTrustManager("TLSSocketFactory")}, null);
                this.internalSSLSocketFactory = this.mSslContext.getSocketFactory();
            }

            private Socket enableTLSOnSocket(Socket socket) {
                if (socket != null && (socket instanceof SSLSocket)) {
                    try {
                        ((SSLSocket) socket).getEnabledProtocols();
                    } catch (IllegalArgumentException e) {
                        e.getMessage();
                    }
                }
                return socket;
            }

            private Socket vg_createSocket(String str, int i) {
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                sSLContext.init(this.mKeyManagers, new TrustManager[]{TTHelper.this.new StrictTrustManager("vg_createSocket", str, i)}, null);
                return sSLContext.getSocketFactory().createSocket(str, i);
            }

            @Override
            public Socket createSocket(String str, int i) {
                try {
                    return enableTLSOnSocket(vg_createSocket(str, i));
                } catch (KeyManagementException | NoSuchAlgorithmException unused) {
                    return enableTLSOnSocket(this.internalSSLSocketFactory.createSocket(str, i));
                }
            }

            @Override
            public String[] getDefaultCipherSuites() {
                return this.internalSSLSocketFactory.getDefaultCipherSuites();
            }

            @Override
            public String[] getSupportedCipherSuites() {
                return this.internalSSLSocketFactory.getSupportedCipherSuites();
            }

            public TLSSocketFactory(URL url, byte[] bArr, String str) {
                this.TAG = TLSSocketFactory.class.getSimpleName();
                this.mKeyManagers = null;
                TrustManager[] trustManagerArr = new TrustManager[1];
                trustManagerArr[0] = TTHelper.this.new StrictTrustManager("TLSSocketFactory", url.getHost(), url.getPort() == -1 ? url.getDefaultPort() : url.getPort());
                KeyStore keyStore = KeyStore.getInstance("PKCS12");
                if (bArr != null && str != null) {
                    keyStore.load(new ByteArrayInputStream(bArr), str.toCharArray());
                    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
                    keyManagerFactory.init(keyStore, str.toCharArray());
                    this.mKeyManagers = keyManagerFactory.getKeyManagers();
                }
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                this.mSslContext = sSLContext;
                sSLContext.init(this.mKeyManagers, trustManagerArr, null);
                this.internalSSLSocketFactory = this.mSslContext.getSocketFactory();
            }

            private Socket vg_createSocket(String str, int i, InetAddress inetAddress, int i2) {
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                sSLContext.init(this.mKeyManagers, new TrustManager[]{TTHelper.this.new StrictTrustManager("vg_createSocket", str, i)}, null);
                return sSLContext.getSocketFactory().createSocket(str, i, inetAddress, i2);
            }

            @Override
            public Socket createSocket(String str, int i, InetAddress inetAddress, int i2) {
                try {
                    return enableTLSOnSocket(vg_createSocket(str, i, inetAddress, i2));
                } catch (KeyManagementException | NoSuchAlgorithmException unused) {
                    return enableTLSOnSocket(this.internalSSLSocketFactory.createSocket(str, i, inetAddress, i2));
                }
            }

            private Socket vg_createSocket(InetAddress inetAddress, int i) {
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                sSLContext.init(this.mKeyManagers, new TrustManager[]{TTHelper.this.new StrictTrustManager("vg_createSocket", inetAddress.getHostName(), i)}, null);
                return sSLContext.getSocketFactory().createSocket(inetAddress, i);
            }

            @Override
            public Socket createSocket(InetAddress inetAddress, int i) {
                Objects.toString(inetAddress);
                try {
                    return enableTLSOnSocket(vg_createSocket(inetAddress, i));
                } catch (KeyManagementException | NoSuchAlgorithmException unused) {
                    return enableTLSOnSocket(this.internalSSLSocketFactory.createSocket(inetAddress, i));
                }
            }

            private Socket vg_createSocket(InetAddress inetAddress, int i, InetAddress inetAddress2, int i2) {
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                sSLContext.init(this.mKeyManagers, new TrustManager[]{TTHelper.this.new StrictTrustManager("vg_createSocket", inetAddress.getHostName(), i)}, null);
                return sSLContext.getSocketFactory().createSocket(inetAddress, i, inetAddress2, i2);
            }

            @Override
            public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress2, int i2) {
                inetAddress.getHostName();
                try {
                    return enableTLSOnSocket(vg_createSocket(inetAddress, i, inetAddress2, i2));
                } catch (KeyManagementException | NoSuchAlgorithmException unused) {
                    return enableTLSOnSocket(this.internalSSLSocketFactory.createSocket(inetAddress, i, inetAddress2, i2));
                }
            }

            private Socket vg_createSocket(Socket socket, String str, int i, boolean z) {
                SSLContext sSLContext = SSLContext.getInstance("TLSv1.2");
                sSLContext.init(this.mKeyManagers, new TrustManager[]{TTHelper.this.new StrictTrustManager("vg_createSocket", str, i)}, null);
                return sSLContext.getSocketFactory().createSocket(socket, str, i, z);
            }

            @Override
            public Socket createSocket(Socket socket, String str, int i, boolean z) {
                try {
                    return enableTLSOnSocket(vg_createSocket(socket, str, i, z));
                } catch (KeyManagementException | NoSuchAlgorithmException unused) {
                    return enableTLSOnSocket(this.internalSSLSocketFactory.createSocket(socket, str, i, z));
                }
            }
        }

        private String createCnonce() {
            return new String(VosWrapperBase.encodeHex(createMessageDigest("MD5").digest(Long.toString(System.currentTimeMillis()).getBytes("US-ASCII"))));
        }

        private MessageDigest createMessageDigest(String str) {
            return MessageDigest.getInstance(str);
        }

        private String processChallenge(URL url, String str, String str2) {
            if (!str2.startsWith("Digest")) {
                String str3 = this.userId + ":" + this.userPassword;
                return j.a("Basic ", Base64.encodeToString(str3.getBytes(), 0, str3.getBytes().length, 0));
            }
            String[] split = str2.replaceFirst("Digest", "").split(",");
            HashMap hashMap = new HashMap();
            for (String str4 : split) {
                String[] split2 = str4.trim().split("=", 2);
                String str5 = split2[0];
                String str6 = split2[1];
                hashMap.put(str5, str6.substring(1, str6.length() - 1));
            }
            String file = url.getFile();
            MessageDigest createMessageDigest = createMessageDigest("MD5");
            String str7 = new String(VosWrapperBase.encodeHex(createMessageDigest.digest(("" + this.userId + ":" + ((String) hashMap.get("realm")) + ":" + this.userPassword).getBytes("US-ASCII"))));
            createMessageDigest.reset();
            StringBuilder sb = new StringBuilder();
            sb.append(str);
            sb.append(":");
            sb.append(file);
            String str8 = new String(VosWrapperBase.encodeHex(createMessageDigest.digest(sb.toString().getBytes("UTF-8"))));
            String createCnonce = createCnonce();
            StringBuilder e = z42.e(str7, ":");
            zz1.c(e, (String) hashMap.get("nonce"), ":00000001:", createCnonce, ":");
            e.append((String) hashMap.get("qop"));
            e.append(":");
            e.append(str8);
            String str9 = new String(VosWrapperBase.encodeHex(createMessageDigest.digest(e.toString().getBytes("UTF-8"))));
            StringBuilder sb2 = new StringBuilder("Digest username=\"");
            sb2.append(this.userId);
            sb2.append("\", realm=\"");
            sb2.append((String) hashMap.get("realm"));
            sb2.append("\", nonce=\"");
            zz1.c(sb2, (String) hashMap.get("nonce"), "\", uri=\"", file, "\", response=\"");
            sb2.append(str9);
            sb2.append("\", qop=\"");
            return ko5.b(sb2, (String) hashMap.get("qop"), "\", nc=00000001, cnonce=\"", createCnonce, "\"");
        }

        public void setResult(String str) {
            this.result = str;
        }

        public void setStatusCode(int i) {
            this.statusCode = i;
        }

        private static String streamToString(InputStream inputStream) {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            while (true) {
                String readLine = bufferedReader.readLine();
                if (readLine == null) {
                    return sb.toString();
                }
                sb.append(readLine);
            }
        }

        public void fetch(final byte[] bArr, final String str) {
            setResult(null);
            setStatusCode(0);
            setEndTime(null);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    TTHelper tTHelper;
                    int i;
                    int[] iArr = new int[1];
                    try {
                        String str2 = TTHelper.this.get_urlconnection(null, iArr, bArr, str);
                        int i2 = iArr[0];
                        int i3 = i2 / 100;
                        if (i3 == 2) {
                            TTHelper.this.setEndTime(new Date());
                            TTHelper.this.setResult(str2);
                            return;
                        }
                        if (i2 == 401) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_AUTHENTICATION_FAILED;
                        } else if (i3 == 4) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_RESPONSE_FAILED;
                        } else if (i3 == 5) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_SERVER_FAILED;
                        } else {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_UNKNOWN_ERROR;
                        }
                        tTHelper.setStatusCode(i);
                    } catch (SocketTimeoutException unused) {
                        TTHelper.this.setStatusCode(VosError.VM_ERR_TRT_REQUEST_TIMEOUT);
                    } catch (Exception unused2) {
                        TTHelper.this.setStatusCode(VosError.VM_ERR_TRT_CONNECTION_FAILED);
                    }
                }
            }).start();
        }

        public Date getEndTime() {
            return this.endTime;
        }

        public String getResult() {
            return this.result;
        }

        public int getStatusCode() {
            return this.statusCode;
        }

        public java.lang.String get_urlconnection(java.lang.String r11, int[] r12, byte[] r13, java.lang.String r14) {
            throw new UnsupportedOperationException("Method not decompiled: vkey.android.vos.VosWrapperBase.TTHelper.get_urlconnection(java.lang.String, int[], byte[], java.lang.String):java.lang.String");
        }

        public java.lang.String post_urlconnection(java.lang.String r11, int[] r12, byte[] r13, java.lang.String r14) {
            throw new UnsupportedOperationException("Method not decompiled: vkey.android.vos.VosWrapperBase.TTHelper.post_urlconnection(java.lang.String, int[], byte[], java.lang.String):java.lang.String");
        }

        public void send(final byte[] bArr, final String str) {
            setResult(null);
            setStatusCode(0);
            setEndTime(null);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    TTHelper tTHelper;
                    int i;
                    int[] iArr = new int[1];
                    try {
                        String post_urlconnection = TTHelper.this.post_urlconnection(null, iArr, bArr, str);
                        int i2 = iArr[0];
                        int i3 = i2 / 100;
                        if (i3 == 2) {
                            TTHelper.this.setEndTime(new Date());
                            TTHelper.this.setResult(post_urlconnection);
                            return;
                        }
                        if (i2 == 401) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_AUTHENTICATION_FAILED;
                        } else if (i3 == 4) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_RESPONSE_FAILED;
                        } else if (i3 == 5) {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_SERVER_FAILED;
                        } else {
                            tTHelper = TTHelper.this;
                            i = VosError.VM_ERR_TRT_UNKNOWN_ERROR;
                        }
                        tTHelper.setStatusCode(i);
                    } catch (SocketTimeoutException unused) {
                        TTHelper.this.setStatusCode(VosError.VM_ERR_TRT_REQUEST_TIMEOUT);
                    } catch (Exception unused2) {
                        TTHelper.this.setStatusCode(VosError.VM_ERR_TRT_CONNECTION_FAILED);
                    }
                }
            }).start();
        }

        public void setEndTime(Date date) {
            this.endTime = date;
        }
    }

    static {
        try {
            System.loadLibrary("vosWrapperEx");
        } catch (Exception e) {
            e.printStackTrace();
        }
        ctx = null;
        hexArray = "0123456789abcdef".toCharArray();
        helper = new TTHelper();
    }

    public static native void Log(LogLevel logLevel, short s, String str, String str2, String str3, String str4, Object... objArr);

    private static HashMap callRestAPI(String str, String str2, String str3, String str4, String str5, int i) {
        a aVar = new a(str);
        aVar.a(str2);
        aVar.a(str3, str4);
        aVar.b(str5);
        aVar.a(i);
        aVar.b();
        while (true) {
            int c = aVar.c();
            if (c != 0) {
                String d = aVar.d();
                HashMap hashMap = new HashMap();
                hashMap.put(CheckoutComponentResponse.ATTR_JSON_STATUS, new Integer(c).toString());
                hashMap.put("jResp", d);
                return hashMap;
            }
            try {
                Thread.sleep(200L);
            } catch (InterruptedException unused) {
            }
        }
    }

    public static native synchronized int celJwsVerifyNative(String str);

    public static native synchronized int cfoJwsVerifyNative(String str);

    private static int checkIfTIDFileExist(String str) {
        File file;
        try {
            if (Build.VERSION.SDK_INT >= 29) {
                file = new File(ctx.getFilesDir(), str);
            } else {
                migrateTIDIfNeeded(str);
                file = new File(ctx.getExternalFilesDir(null).getParentFile().getParentFile().getParentFile(), str);
            }
            return file.exists() ? 1 : 0;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    private static int deleteTempFW(String str, int i) {
        if (i != 0) {
            return 1;
        }
        File file = new File(b02.b(pq0.b(new StringBuilder(), ctx.getApplicationInfo().dataDir, "/files/"), str));
        if (!file.exists()) {
            return 1;
        }
        file.delete();
        return 1;
    }

    private static int detectArtifactBased(String str, int i) {
        return new File(str).exists() ? i : 1 - i;
    }

    private static int detectContentBased(String str, String str2, int i) {
        File file = new File(str);
        boolean z = false;
        if (!file.exists()) {
            return 0;
        }
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            while (true) {
                String readLine = bufferedReader.readLine();
                if (readLine == null) {
                    break;
                }
                if (readLine.contains(str2)) {
                    z = true;
                    break;
                }
            }
        } catch (Exception unused) {
        }
        return z ? i : 1 - i;
    }

    private static int detectSystemProperty(String str, String str2, int i) {
        String readLine;
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(new File("/system/build.prop")));
            do {
                readLine = bufferedReader.readLine();
                if (readLine == null) {
                    return 0;
                }
            } while (!readLine.startsWith(str));
            return readLine.contains(str2) ? i : 1 - i;
        } catch (Exception unused) {
            return 0;
        }
    }

    public static char[] encodeHex(byte[] bArr) {
        char[] cArr = new char[bArr.length * 2];
        for (int i = 0; i < bArr.length; i++) {
            int i2 = bArr[i] & 255;
            int i3 = i * 2;
            char[] cArr2 = hexArray;
            cArr[i3] = cArr2[i2 >>> 4];
            cArr[i3 + 1] = cArr2[i2 & 15];
        }
        return cArr;
    }

    private static int g() {
        vkey.android.vos.a.b bVar = f;
        int i = bVar.d;
        int i2 = bVar.e;
        int i3 = bVar.f;
        int i4 = i == 1 ? 1 : 0;
        if (i2 == 1) {
            i4++;
        }
        if (i3 == 1) {
            i4++;
        }
        if (i4 != 3) {
            return 0;
        }
        Log(LogLevel.LOG_LEVEL_ERROR, (short) 3, "vos-processor", "Nyn63BHCcXbmvDQRmGv2a7", "cC75KFnGNejEQXNEKBvJXZ", "Eqx6bNHcCRjuctS7dDxgHF", new Object[0]);
        return 1;
    }

    private static byte[] getAndroidId() {
        String str = null;
        try {
            str = Settings.Secure.getString(ctx.getContentResolver(), "android_id");
            if (str == null) {
                str = "";
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str.getBytes();
    }

    private static byte[] getAppId() {
        String str = ctx.getApplicationInfo().processName;
        if (str == null) {
            str = "";
        }
        return str.getBytes();
    }

    private static String getAppSignerHash() {
        try {
            Signature[] signatureArr = ctx.getPackageManager().getPackageInfo(ctx.getPackageName(), 64).signatures;
            if (signatureArr.length <= 0) {
                return null;
            }
            byte[] encoded = ((X509Certificate) CertificateFactory.getInstance("X509").generateCertificate(new ByteArrayInputStream(signatureArr[0].toByteArray()))).getEncoded();
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.reset();
            return new String(encodeHex(messageDigest.digest(encoded)));
        } catch (Exception unused) {
            return null;
        }
    }

    public static native synchronized String getCelJwsHashNative();

    public static native synchronized String getCelPayloadNative();

    private static byte[] getDefaultPath() {
        try {
            return (ctx.getFilesDir().getAbsolutePath() + File.separator).getBytes();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static int getDefaultPathLength() {
        try {
            return (ctx.getFilesDir().getAbsolutePath() + File.separator).length();
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    private static String getDeviceModel() {
        return Build.MANUFACTURER + " " + Build.MODEL;
    }

    private static byte[] getFilePath(String str) {
        try {
            return (ctx.getFilesDir().getAbsolutePath() + File.separator + str).getBytes();
        } catch (Exception e) {
            e.printStackTrace();
            return str.getBytes();
        }
    }

    private static int getFilePathLength(String str) {
        try {
            return (ctx.getFilesDir().getAbsolutePath() + File.separator + str).length();
        } catch (Exception e) {
            e.printStackTrace();
            return str.length();
        }
    }

    private static byte[] getIMEI() {
        String str = "";
        try {
            String deviceId = ((TelephonyManager) ctx.getSystemService("phone")).getDeviceId();
            if (deviceId != null) {
                str = deviceId;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str.getBytes();
    }

    private static byte[] getMacAddress() {
        return ((WifiManager) ctx.getSystemService("wifi")).getConnectionInfo().getMacAddress().replace(":", "").getBytes("UTF8");
    }

    public static native synchronized byte[] getMtlsCertificateNative();

    public static native synchronized String getMtlsPasswordNative();

    private static String getOperatingSystem() {
        return Build.VERSION.RELEASE;
    }

    private static byte[] getPBKDF2(byte[] bArr, int i, byte[] bArr2, int i2) {
        return SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1").generateSecret(new PBEKeySpec(new String(bArr, "UTF-8").toCharArray(), bArr2, WebSocket.CLOSE_CODE_NORMAL, i2 * 8)).getEncoded();
    }

    private static byte[] getSecureRandomBytes(int i) {
        byte[] bArr = new byte[i];
        new SecureRandom().nextBytes(bArr);
        return bArr;
    }

    private static String getTrustedTimeStatus(int[] iArr, int[] iArr2) {
        String result = helper.getResult();
        int statusCode = helper.getStatusCode();
        if (result != null && helper.getEndTime() != null) {
            if (iArr.length > 0) {
                iArr[0] = statusCode;
            }
            if (iArr2.length > 0) {
                iArr2[0] = ((int) (new Date().getTime() - helper.getEndTime().getTime())) / WebSocket.CLOSE_CODE_NORMAL;
            }
            return result;
        }
        if (statusCode == 0) {
            if (iArr.length > 0) {
                iArr[0] = 123456;
            }
            if (iArr2.length > 0) {
                iArr2[0] = 0;
            }
            return null;
        }
        if (iArr.length > 0) {
            iArr[0] = statusCode;
        }
        if (iArr2.length > 0) {
            iArr2[0] = 0;
        }
        return null;
    }

    private static byte[] getVAData(String str, int i) {
        byte[] bArr = null;
        try {
            InputStream bufferedInputStream = i == 1 ? new BufferedInputStream(new FileInputStream(new File(str))) : ctx.getAssets().open(str);
            bArr = new byte[bufferedInputStream.available()];
            bufferedInputStream.read(bArr);
            bufferedInputStream.close();
            return bArr;
        } catch (IOException e) {
            e.printStackTrace();
            return bArr;
        }
    }

    private static int getVADataLength(String str, int i) {
        try {
            InputStream bufferedInputStream = i == 1 ? new BufferedInputStream(new FileInputStream(new File(str))) : ctx.getAssets().open(str);
            int available = bufferedInputStream.available();
            bufferedInputStream.close();
            return available;
        } catch (IOException unused) {
            return -1;
        }
    }

    private static String getVAFilepath(String str, int i) {
        if (i != 0 || str.charAt(0) == '/') {
            return str;
        }
        String b = pq0.b(new StringBuilder(), ctx.getApplicationInfo().dataDir, "/files/");
        File file = new File(b02.b(b, str));
        File parentFile = file.getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        if (file.exists()) {
            file.delete();
        }
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            InputStream open = ctx.getAssets().open(str);
            byte[] bArr = new byte[1024];
            while (true) {
                int read = open.read(bArr);
                if (read <= 0) {
                    open.close();
                    fileOutputStream.close();
                    return b02.b(b, str);
                }
                fileOutputStream.write(bArr, 0, read);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

    private static int isEmulator() {
        return detectContentBased("/proc/ioports", "0ff :", 1) + 0 + detectArtifactBased("/sys/devices/virtual/ppp", 0) + detectArtifactBased("/sys/devices/virtual/switch", 0) + detectArtifactBased("/sys/devices/system/cpu/cpu0/cpufreq", 0) + detectArtifactBased("/sys/devices/virtual/misc/android_adb", 0) + detectArtifactBased("/sys/class/net/eth0", 1) + detectSystemProperty("rild.libpath", "/system/lib/libreference-ril.so", 1) + detectSystemProperty("ro.build.display.id", "test-", 1);
    }

    private static int isRunningInForeground() {
        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = ((ActivityManager) ctx.getSystemService("activity")).getRunningAppProcesses();
        if (runningAppProcesses == null) {
            return 0;
        }
        String packageName = ctx.getPackageName();
        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
            if (runningAppProcessInfo.importance == 100 && runningAppProcessInfo.processName.equals(packageName)) {
                return 1;
            }
        }
        return 0;
    }

    public static native void logMetadata();

    private static void migrateTIDIfNeeded(String str) {
        try {
            File file = new File(ctx.getExternalFilesDir(null).getParentFile().getParentFile().getParentFile(), str);
            if (file.exists()) {
                return;
            }
            File file2 = new File(ctx.getExternalFilesDir(null).getParentFile().getParentFile(), str);
            if (!file2.exists()) {
                return;
            }
            try {
                FileInputStream fileInputStream = new FileInputStream(file2);
                try {
                    FileOutputStream fileOutputStream = new FileOutputStream(file);
                    try {
                        byte[] bArr = new byte[1024];
                        while (true) {
                            int read = fileInputStream.read(bArr);
                            if (read <= 0) {
                                fileOutputStream.close();
                                fileInputStream.close();
                                return;
                            }
                            fileOutputStream.write(bArr, 0, read);
                        }
                    } finally {
                    }
                } finally {
                }
            } catch (Exception unused) {
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static byte[] readFromTIDFile(File file) {
        byte[] bArr = null;
        if (file != null && file.exists()) {
            try {
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
                try {
                    bArr = new byte[(int) randomAccessFile.length()];
                    randomAccessFile.readFully(bArr);
                    randomAccessFile.close();
                } finally {
                }
            } catch (Exception unused) {
            }
        }
        return bArr;
    }

    private static int requestServerTime(String str, String str2, String str3, int i, byte[] bArr, String str4) {
        TTHelper tTHelper = new TTHelper();
        helper = tTHelper;
        tTHelper.context = ctx.getApplicationContext();
        helper.userId = str;
        helper.userPassword = str2;
        helper.url = str3;
        helper.timeoutSeconds = i;
        helper.fetch(bArr, str4);
        return 0;
    }

    private static int s() {
        vkey.android.vos.a.b bVar = new vkey.android.vos.a.b(ctx);
        f = bVar;
        bVar.a();
        return f.c();
    }

    private static void sendTrackingRequest(String str, String str2, String str3, byte[] bArr, int i, byte[] bArr2, String str4) {
        TTHelper tTHelper = new TTHelper();
        helper = tTHelper;
        tTHelper.context = ctx.getApplicationContext();
        helper.requestBuffer = bArr;
        helper.requestSize = i;
        helper.userId = str2;
        helper.userPassword = str3;
        helper.url = str;
        helper.send(bArr2, str4);
    }

    private static int writeToTIDFile(File file, byte[] bArr, int i) {
        int i2 = 0;
        if (file != null) {
            if (file.exists()) {
                file.delete();
            }
            try {
                RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
                try {
                    randomAccessFile.write(bArr);
                    i2 = 1;
                    randomAccessFile.close();
                } finally {
                }
            } catch (Exception unused) {
            }
        }
        return i2;
    }

    public native void forceSyncLogs();

    public native int initVSSecureLog(String str);

    public native void log(LogLevel logLevel, short s, String str, String str2, String str3, String str4, Object... objArr);

    public native void setLoggerBaseUrl(String str);

    private static byte[] readFromTIDFile(String str) {
        byte[] bArr = null;
        try {
            int i = Build.VERSION.SDK_INT;
            bArr = readFromTIDFile(i >= 29 ? new File(ctx.getFilesDir(), str) : new File(ctx.getExternalFilesDir(null).getParentFile().getParentFile().getParentFile(), str));
            if (bArr == null && i < 29) {
                bArr = readFromTIDFile(new File(ctx.getFilesDir(), str));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bArr == null ? new byte[0] : bArr;
    }

    private static int writeToTIDFile(String str, byte[] bArr, int i) {
        try {
            int i2 = Build.VERSION.SDK_INT;
            int writeToTIDFile = writeToTIDFile(i2 >= 29 ? new File(ctx.getFilesDir(), str) : new File(ctx.getExternalFilesDir(null).getParentFile().getParentFile().getParentFile(), str), bArr, i);
            return (writeToTIDFile == 1 || i2 >= 29) ? writeToTIDFile : writeToTIDFile(new File(ctx.getFilesDir(), str), bArr, i);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}