OVO v3.139.0 - rdb.java 源代码

package o.i;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;
import java.security.AccessController;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivilegedActionException;
import java.security.Provider;
import java.security.Security;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLSocket;

public class rdb {
    public static final Logger b = Logger.getLogger(rdb.class.getName());
    public static final String[] c = {"com.google.android.gms.org.conscrypt.OpenSSLProvider", "org.conscrypt.OpenSSLProvider", "com.android.org.conscrypt.OpenSSLProvider", "org.apache.harmony.xnet.provider.jsse.OpenSSLProvider", "com.google.android.libraries.stitch.sslguard.SslGuardProvider"};
    public static final rdb d;
    public final Provider a;

    public static class a extends rdb {
        public final wha<Socket> e;
        public final wha<Socket> f;
        public final wha<Socket> g;
        public final wha<Socket> h;
        public final e i;

        public a(wha whaVar, wha whaVar2, wha whaVar3, wha whaVar4, Provider provider, e eVar) {
            super(provider);
            this.e = whaVar;
            this.f = whaVar2;
            this.g = whaVar3;
            this.h = whaVar4;
            this.i = eVar;
        }

        @Override
        public final void c(SSLSocket sSLSocket, String str, List<dvb> list) {
            if (str != null) {
                this.e.d(new Object[]{Boolean.TRUE}, sSLSocket);
                this.f.d(new Object[]{str}, sSLSocket);
            }
            wha<Socket> whaVar = this.h;
            whaVar.getClass();
            if (whaVar.a(sSLSocket.getClass()) != null) {
                whaVar.e(new Object[]{rdb.b(list)}, sSLSocket);
            }
        }

        @Override
        public final String d(SSLSocket sSLSocket) {
            byte[] bArr;
            wha<Socket> whaVar = this.g;
            whaVar.getClass();
            if ((whaVar.a(sSLSocket.getClass()) != null) && (bArr = (byte[]) whaVar.e(new Object[0], sSLSocket)) != null) {
                return new String(bArr, iag.b);
            }
            return null;
        }

        @Override
        public final e e() {
            return this.i;
        }
    }

    public static class b extends rdb {
        public final Method e;
        public final Method f;

        public b(Provider provider, Method method, Method method2) {
            super(provider);
            this.e = method;
            this.f = method2;
        }

        @Override
        public final void c(SSLSocket sSLSocket, String str, List<dvb> list) {
            SSLParameters sSLParameters = sSLSocket.getSSLParameters();
            ArrayList arrayList = new ArrayList(list.size());
            for (dvb dvbVar : list) {
                if (dvbVar != dvb.HTTP_1_0) {
                    arrayList.add(dvbVar.toString());
                }
            }
            try {
                this.e.invoke(sSLParameters, arrayList.toArray(new String[arrayList.size()]));
                sSLSocket.setSSLParameters(sSLParameters);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e2) {
                throw new RuntimeException(e2);
            }
        }

        @Override
        public final String d(SSLSocket sSLSocket) {
            try {
                return (String) this.f.invoke(sSLSocket, new Object[0]);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e2) {
                throw new RuntimeException(e2);
            }
        }

        @Override
        public final e e() {
            return e.ALPN_AND_NPN;
        }
    }

    public static class c extends rdb {
        public final Method e;
        public final Method f;
        public final Method g;
        public final Class<?> h;
        public final Class<?> i;

        public c(Method method, Method method2, Method method3, Class<?> cls, Class<?> cls2, Provider provider) {
            super(provider);
            this.e = method;
            this.f = method2;
            this.g = method3;
            this.h = cls;
            this.i = cls2;
        }

        @Override
        public final void a(SSLSocket sSLSocket) {
            try {
                this.g.invoke(null, sSLSocket);
            } catch (IllegalAccessException unused) {
                throw new AssertionError();
            } catch (InvocationTargetException e) {
                rdb.b.log(Level.FINE, "Failed to remove SSLSocket from Jetty ALPN", (Throwable) e);
            }
        }

        @Override
        public final void c(SSLSocket sSLSocket, String str, List<dvb> list) {
            ArrayList arrayList = new ArrayList(list.size());
            int size = list.size();
            for (int i = 0; i < size; i++) {
                dvb dvbVar = list.get(i);
                if (dvbVar != dvb.HTTP_1_0) {
                    arrayList.add(dvbVar.toString());
                }
            }
            try {
                this.e.invoke(null, sSLSocket, Proxy.newProxyInstance(rdb.class.getClassLoader(), new Class[]{this.h, this.i}, new d(arrayList)));
            } catch (IllegalAccessException e) {
                throw new AssertionError(e);
            } catch (InvocationTargetException e2) {
                throw new AssertionError(e2);
            }
        }

        @Override
        public final String d(SSLSocket sSLSocket) {
            try {
                d dVar = (d) Proxy.getInvocationHandler(this.f.invoke(null, sSLSocket));
                boolean z = dVar.b;
                if (!z && dVar.c == null) {
                    rdb.b.log(Level.INFO, "ALPN callback dropped: SPDY and HTTP/2 are disabled. Is alpn-boot on the boot class path?");
                    return null;
                }
                if (z) {
                    return null;
                }
                return dVar.c;
            } catch (IllegalAccessException unused) {
                throw new AssertionError();
            } catch (InvocationTargetException unused2) {
                throw new AssertionError();
            }
        }

        @Override
        public final e e() {
            return e.ALPN_AND_NPN;
        }
    }

    public static class d implements InvocationHandler {
        public final List<String> a;
        public boolean b;
        public String c;

        public d(ArrayList arrayList) {
            this.a = arrayList;
        }

        @Override
        public final Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
            String name = method.getName();
            Class<?> returnType = method.getReturnType();
            if (objArr == null) {
                objArr = iag.a;
            }
            if (name.equals("supports") && Boolean.TYPE == returnType) {
                return Boolean.TRUE;
            }
            if (name.equals("unsupported") && Void.TYPE == returnType) {
                this.b = true;
                return null;
            }
            boolean equals = name.equals("protocols");
            List<String> list = this.a;
            if (equals && objArr.length == 0) {
                return list;
            }
            if ((name.equals("selectProtocol") || name.equals("select")) && String.class == returnType && objArr.length == 1) {
                Object obj2 = objArr[0];
                if (obj2 instanceof List) {
                    List list2 = (List) obj2;
                    int size = list2.size();
                    for (int i = 0; i < size; i++) {
                        if (list.contains(list2.get(i))) {
                            String str = (String) list2.get(i);
                            this.c = str;
                            return str;
                        }
                    }
                    String str2 = list.get(0);
                    this.c = str2;
                    return str2;
                }
            }
            if ((!name.equals("protocolSelected") && !name.equals("selected")) || objArr.length != 1) {
                return method.invoke(this, objArr);
            }
            this.c = (String) objArr[0];
            return null;
        }
    }

    public enum e {
        ALPN_AND_NPN,
        NPN,
        NONE
    }

    static {
        Logger logger;
        Provider provider;
        rdb rdbVar;
        rdb rdbVar2;
        e eVar;
        boolean z;
        Provider[] providers = Security.getProviders();
        int length = providers.length;
        boolean z2 = false;
        int i = 0;
        loop0: while (true) {
            logger = b;
            if (i >= length) {
                logger.log(Level.WARNING, "Unable to find Conscrypt");
                provider = null;
                break;
            }
            Provider provider2 = providers[i];
            for (String str : c) {
                if (str.equals(provider2.getClass().getName())) {
                    logger.log(Level.FINE, "Found registered provider {0}", str);
                    provider = provider2;
                    break loop0;
                }
            }
            i++;
        }
        if (provider != null) {
            wha whaVar = new wha(null, "setUseSessionTickets", Boolean.TYPE);
            wha whaVar2 = new wha(null, "setHostname", String.class);
            wha whaVar3 = new wha(byte[].class, "getAlpnSelectedProtocol", new Class[0]);
            wha whaVar4 = new wha(null, "setAlpnProtocols", byte[].class);
            try {
                Class<?> cls = Class.forName("android.net.TrafficStats");
                cls.getMethod("tagSocket", Socket.class);
                cls.getMethod("untagSocket", Socket.class);
            } catch (ClassNotFoundException | NoSuchMethodException unused) {
            }
            if (provider.getName().equals("GmsCore_OpenSSL") || provider.getName().equals("Conscrypt") || provider.getName().equals("Ssl_Guard")) {
                eVar = e.ALPN_AND_NPN;
            } else {
                try {
                    rdb.class.getClassLoader().loadClass("android.net.Network");
                    z = true;
                } catch (ClassNotFoundException e2) {
                    logger.log(Level.FINE, "Can't find class", (Throwable) e2);
                    z = false;
                }
                if (z) {
                    eVar = e.ALPN_AND_NPN;
                } else {
                    try {
                        rdb.class.getClassLoader().loadClass("android.app.ActivityOptions");
                        z2 = true;
                    } catch (ClassNotFoundException e3) {
                        logger.log(Level.FINE, "Can't find class", (Throwable) e3);
                    }
                    eVar = z2 ? e.NPN : e.NONE;
                }
            }
            rdbVar2 = new a(whaVar, whaVar2, whaVar3, whaVar4, provider, eVar);
        } else {
            try {
                Provider provider3 = SSLContext.getDefault().getProvider();
                try {
                    SSLContext sSLContext = SSLContext.getInstance("TLS", provider3);
                    sSLContext.init(null, null, null);
                    ((Method) AccessController.doPrivileged(new odb())).invoke(sSLContext.createSSLEngine(), new Object[0]);
                    rdbVar2 = new b(provider3, (Method) AccessController.doPrivileged(new pdb()), (Method) AccessController.doPrivileged(new qdb()));
                } catch (IllegalAccessException | InvocationTargetException | KeyManagementException | NoSuchAlgorithmException | PrivilegedActionException unused2) {
                    try {
                        Class<?> cls2 = Class.forName("org.eclipse.jetty.alpn.ALPN");
                        rdbVar = new c(cls2.getMethod("put", SSLSocket.class, Class.forName("org.eclipse.jetty.alpn.ALPN$Provider")), cls2.getMethod("get", SSLSocket.class), cls2.getMethod("remove", SSLSocket.class), Class.forName("org.eclipse.jetty.alpn.ALPN$ClientProvider"), Class.forName("org.eclipse.jetty.alpn.ALPN$ServerProvider"), provider3);
                    } catch (ClassNotFoundException | NoSuchMethodException unused3) {
                        rdbVar = new rdb(provider3);
                    }
                    rdbVar2 = rdbVar;
                }
            } catch (NoSuchAlgorithmException e4) {
                throw new RuntimeException(e4);
            }
        }
        d = rdbVar2;
    }

    public rdb(Provider provider) {
        this.a = provider;
    }

    public static byte[] b(List<dvb> list) {
        yu0 yu0Var = new yu0();
        int size = list.size();
        for (int i = 0; i < size; i++) {
            dvb dvbVar = list.get(i);
            if (dvbVar != dvb.HTTP_1_0) {
                yu0Var.K(dvbVar.toString().length());
                yu0Var.b0(dvbVar.toString());
            }
        }
        return yu0Var.J0();
    }

    public void a(SSLSocket sSLSocket) {
    }

    public void c(SSLSocket sSLSocket, String str, List<dvb> list) {
    }

    public String d(SSLSocket sSLSocket) {
        return null;
    }

    public e e() {
        return e.NONE;
    }
}