Picsart v24.6版本的 MD5 值为：21a61631d94e54da68d2ad9268b8b9d9

以下内容为反编译后的 c.java 源代码，内容仅作参考

package myobfuscated.iv;

import com.koushikdutta.async.AsyncSSLException;
import com.koushikdutta.async.AsyncServer;
import com.koushikdutta.async.util.ArrayDeque;
import java.nio.ByteBuffer;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLEngineResult;
import javax.net.ssl.SSLException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import myobfuscated.ov.b;
import org.apache.http.conn.ssl.AbstractVerifier;
import org.apache.http.conn.ssl.StrictHostnameVerifier;
public final class c implements h, l, myobfuscated.iv.b {
    public final h a;
    public final i b;
    public boolean c;
    public final SSLEngine d;
    public boolean e;
    public final String f;
    public boolean g;
    public final HostnameVerifier h;
    public e i;
    public X509Certificate[] j;
    public myobfuscated.jv.d k;
    public myobfuscated.jv.b l;
    public final boolean m;
    public boolean n;
    public Exception o;
    public final j p = new j();
    public final C1187c q;
    public final j r;
    public myobfuscated.jv.a s;

    public static class a implements X509TrustManager {
        @Override
        public final void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

        @Override
        public final void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) {
            for (X509Certificate x509Certificate : x509CertificateArr) {
                if (x509Certificate != null && x509Certificate.getCriticalExtensionOIDs() != null) {
                    x509Certificate.getCriticalExtensionOIDs().remove("2.5.29.15");
                }
            }
        }

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

    public static class b implements X509TrustManager {
        @Override
        public final void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

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

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

    public class C1187c implements myobfuscated.jv.b {
        public final myobfuscated.rv.a a;
        public final j b;

        public C1187c() {
            myobfuscated.rv.a aVar = new myobfuscated.rv.a();
            aVar.c = Math.max(0, 8192);
            this.a = aVar;
            this.b = new j();
        }

        @Override
        public final void b(l lVar, j jVar) {
            ByteBuffer m;
            ByteBuffer m2;
            myobfuscated.rv.a aVar = this.a;
            j jVar2 = this.b;
            c cVar = c.this;
            boolean z = cVar.c;
            j jVar3 = cVar.p;
            if (z) {
                return;
            }
            try {
                try {
                    cVar.c = true;
                    jVar.c(jVar2);
                    if (jVar2.g()) {
                        int i = jVar2.c;
                        if (i == 0) {
                            m2 = j.j;
                        } else {
                            jVar2.j(i);
                            m2 = jVar2.m();
                        }
                        jVar2.a(m2);
                    }
                    ByteBuffer byteBuffer = j.j;
                    while (true) {
                        if (byteBuffer.remaining() == 0 && jVar2.a.size() > 0) {
                            byteBuffer = jVar2.m();
                        }
                        int remaining = byteBuffer.remaining();
                        int i2 = jVar3.c;
                        ByteBuffer h = j.h(Math.min(Math.max(aVar.b, aVar.c), aVar.a));
                        SSLEngineResult unwrap = cVar.d.unwrap(byteBuffer, h);
                        h.flip();
                        if (h.hasRemaining()) {
                            jVar3.a(h);
                        } else {
                            j.k(h);
                        }
                        aVar.b = (jVar3.c - i2) * 2;
                        if (unwrap.getStatus() != SSLEngineResult.Status.BUFFER_OVERFLOW) {
                            if (unwrap.getStatus() == SSLEngineResult.Status.BUFFER_UNDERFLOW) {
                                jVar2.b(byteBuffer);
                                if (jVar2.a.size() <= 1) {
                                    break;
                                }
                                int i3 = jVar2.c;
                                if (i3 == 0) {
                                    m = j.j;
                                } else {
                                    jVar2.j(i3);
                                    m = jVar2.m();
                                }
                                jVar2.b(m);
                                byteBuffer = j.j;
                            }
                            cVar.f(unwrap.getHandshakeStatus());
                            if (byteBuffer.remaining() != remaining && i2 == jVar3.c) {
                                jVar2.b(byteBuffer);
                                break;
                            }
                        } else {
                            aVar.c = Math.max(0, aVar.c * 2);
                        }
                        remaining = -1;
                        cVar.f(unwrap.getHandshakeStatus());
                        if (byteBuffer.remaining() != remaining) {
                        }
                    }
                    cVar.j();
                } catch (SSLException e) {
                    cVar.o(e);
                }
                cVar.c = false;
            } catch (Throwable th) {
                cVar.c = false;
                throw th;
            }
        }
    }

    public class d implements Runnable {
        public d() {
        }

        @Override
        public final void run() {
            myobfuscated.jv.d dVar = c.this.k;
            if (dVar != null) {
                dVar.f();
            }
        }
    }

    public interface e {
    }

    static {
        try {
            SSLContext.getInstance("Default");
        } catch (Exception e2) {
            try {
                SSLContext.getInstance("TLS").init(null, new TrustManager[]{new Object()}, null);
            } catch (Exception e3) {
                e2.printStackTrace();
                e3.printStackTrace();
            }
        }
        try {
            SSLContext.getInstance("TLS").init(null, new TrustManager[]{new Object()}, null);
        } catch (Exception e4) {
            e4.printStackTrace();
        }
    }

    public c(myobfuscated.iv.a aVar, SSLEngine sSLEngine) {
        C1187c c1187c = new C1187c();
        this.q = c1187c;
        this.r = new j();
        this.a = aVar;
        this.h = null;
        this.m = false;
        this.d = sSLEngine;
        this.f = null;
        sSLEngine.setUseClientMode(false);
        i iVar = new i(aVar);
        this.b = iVar;
        iVar.c = new myobfuscated.iv.e(this);
        aVar.l = new f(this);
        aVar.h = c1187c;
    }

    @Override
    public final AsyncServer a() {
        return this.a.a();
    }

    @Override
    public final void b() {
        this.a.b();
    }

    @Override
    public final void c() {
        this.a.c();
        j();
    }

    @Override
    public final void close() {
        this.a.close();
    }

    @Override
    public final void d(myobfuscated.jv.d dVar) {
        this.k = dVar;
    }

    @Override
    public final myobfuscated.jv.d e() {
        return this.k;
    }

    public final void f(SSLEngineResult.HandshakeStatus handshakeStatus) {
        h hVar = this.a;
        SSLEngineResult.HandshakeStatus handshakeStatus2 = SSLEngineResult.HandshakeStatus.NEED_TASK;
        SSLEngine sSLEngine = this.d;
        if (handshakeStatus == handshakeStatus2) {
            sSLEngine.getDelegatedTask().run();
        }
        if (handshakeStatus == SSLEngineResult.HandshakeStatus.NEED_WRAP) {
            k(this.r);
        }
        if (handshakeStatus == SSLEngineResult.HandshakeStatus.NEED_UNWRAP) {
            this.q.b(this, new j());
        }
        try {
            if (this.e) {
                return;
            }
            if (sSLEngine.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING && sSLEngine.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.FINISHED) {
                return;
            }
            if (this.m) {
                boolean z = false;
                try {
                    this.j = (X509Certificate[]) sSLEngine.getSession().getPeerCertificates();
                    String str = this.f;
                    if (str != null) {
                        HostnameVerifier hostnameVerifier = this.h;
                        if (hostnameVerifier == null) {
                            new StrictHostnameVerifier().verify(str, AbstractVerifier.getCNs(this.j[0]), AbstractVerifier.getDNSSubjectAlts(this.j[0]));
                        } else if (!hostnameVerifier.verify(str, sSLEngine.getSession())) {
                            throw new SSLException("hostname <" + str + "> has been denied");
                        }
                    }
                    z = true;
                    e = null;
                } catch (SSLException e2) {
                    e = e2;
                }
                this.e = true;
                if (!z) {
                    AsyncSSLException asyncSSLException = new AsyncSSLException(e);
                    o(asyncSSLException);
                    if (!asyncSSLException.getIgnore()) {
                        throw asyncSSLException;
                    }
                }
            } else {
                this.e = true;
            }
            ((b.a) this.i).a(this);
            this.i = null;
            hVar.i(null);
            hVar.a().c(new d());
            j();
        } catch (Exception e3) {
            o(e3);
        }
    }

    @Override
    public final void g(myobfuscated.jv.b bVar) {
        this.l = bVar;
    }

    @Override
    public final myobfuscated.jv.b h() {
        return this.l;
    }

    @Override
    public final void i(myobfuscated.jv.a aVar) {
        this.a.i(aVar);
    }

    public final void j() {
        myobfuscated.jv.a aVar;
        j jVar = this.p;
        myobfuscated.ul.n.D(this, jVar);
        if (!this.n || jVar.g() || (aVar = this.s) == null) {
            return;
        }
        aVar.f(this.o);
    }

    @Override
    public final void k(j jVar) {
        j jVar2 = this.r;
        if (this.g) {
            return;
        }
        i iVar = this.b;
        if (iVar.b.c > 0) {
            return;
        }
        this.g = true;
        int i = (jVar.c * 3) / 2;
        if (i == 0) {
            i = 8192;
        }
        ByteBuffer h = j.h(i);
        SSLEngineResult sSLEngineResult = null;
        do {
            if (!this.e || jVar.c != 0) {
                int i2 = jVar.c;
                try {
                    ArrayDeque<ByteBuffer> arrayDeque = jVar.a;
                    ByteBuffer[] byteBufferArr = (ByteBuffer[]) arrayDeque.toArray(new ByteBuffer[arrayDeque.size()]);
                    arrayDeque.clear();
                    jVar.c = 0;
                    sSLEngineResult = this.d.wrap(byteBufferArr, h);
                    for (ByteBuffer byteBuffer : byteBufferArr) {
                        jVar.a(byteBuffer);
                    }
                    h.flip();
                    jVar2.a(h);
                    if (jVar2.c > 0) {
                        iVar.k(jVar2);
                    }
                    int capacity = h.capacity();
                    try {
                        if (sSLEngineResult.getStatus() == SSLEngineResult.Status.BUFFER_OVERFLOW) {
                            h = j.h(capacity * 2);
                            i2 = -1;
                        } else {
                            int i3 = (jVar.c * 3) / 2;
                            if (i3 == 0) {
                                i3 = 8192;
                            }
                            h = j.h(i3);
                            f(sSLEngineResult.getHandshakeStatus());
                        }
                    } catch (SSLException e2) {
                        e = e2;
                        h = null;
                        o(e);
                        if (i2 != jVar.c) {
                        }
                        if (iVar.b.c != 0) {
                            this.g = false;
                            j.k(h);
                        }
                    }
                } catch (SSLException e3) {
                    e = e3;
                }
                if (i2 != jVar.c && (sSLEngineResult == null || sSLEngineResult.getHandshakeStatus() != SSLEngineResult.HandshakeStatus.NEED_WRAP)) {
                    break;
                }
            } else {
                break;
            }
        } while (iVar.b.c != 0);
        this.g = false;
        j.k(h);
    }

    @Override
    public final void l(myobfuscated.jv.a aVar) {
        this.s = aVar;
    }

    @Override
    public final boolean m() {
        return this.a.m();
    }

    @Override
    public final String n() {
        return null;
    }

    public final void o(Exception exc) {
        if (this.i == null) {
            myobfuscated.jv.a aVar = this.s;
            if (aVar != null) {
                aVar.f(exc);
                return;
            }
            return;
        }
        this.i = null;
        ?? obj = new Object();
        h hVar = this.a;
        hVar.g(obj);
        hVar.b();
        hVar.i(null);
        hVar.close();
    }

    @Override
    public final void pause() {
        this.a.pause();
    }
}