Kaspi.kz v5.85.1 - C0314ciH.java 源代码

package o;

import java.io.IOException;
import java.security.PublicKey;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.CertificateParsingException;
import java.util.Date;
import java.util.Enumeration;
import javax.security.auth.x500.X500Principal;

class C0314ciH extends AbstractC0317ciK implements InterfaceC0362cmk {
    private C0316ciJ AudioAttributesCompatParcelizer;
    private PublicKey AudioAttributesImplApi21Parcelizer;
    private long[] AudioAttributesImplApi26Parcelizer;
    private X500Principal AudioAttributesImplBaseParcelizer;
    private volatile int IconCompatParcelizer;
    private X500Principal MediaBrowserCompatCustomActionResultReceiver;
    private InterfaceC0362cmk read;
    private volatile boolean setElement;
    private final Object write;

    static class setFieldValue extends CertificateEncodingException {
        private final Throwable setBackground;

        setFieldValue(Throwable th) {
            this.setBackground = th;
        }

        @Override
        public Throwable getCause() {
            return this.setBackground;
        }
    }

    C0314ciH(InterfaceC0332clF interfaceC0332clF, bRE bre) throws CertificateParsingException {
        super(interfaceC0332clF, bre, setError(bre), setOptions(bre), setFieldValue(bre), setLabel(bre));
        this.write = new Object();
        this.read = new C0324civ();
    }

    private C0316ciJ RemoteActionCompatParcelizer() {
        byte[] bArr;
        setFieldValue setfieldvalue;
        C0316ciJ c0316ciJ;
        synchronized (this.write) {
            C0316ciJ c0316ciJ2 = this.AudioAttributesCompatParcelizer;
            if (c0316ciJ2 != null) {
                return c0316ciJ2;
            }
            try {
                setfieldvalue = null;
                bArr = this.setError.setOptions("DER");
            } catch (IOException e) {
                bArr = null;
                setfieldvalue = new setFieldValue(e);
            }
            C0316ciJ c0316ciJ3 = new C0316ciJ(this.setBackground, this.setError, this.setOptions, this.setLabel, this.setFieldValue, this.RemoteActionCompatParcelizer, bArr, setfieldvalue);
            synchronized (this.write) {
                if (this.AudioAttributesCompatParcelizer == null) {
                    this.AudioAttributesCompatParcelizer = c0316ciJ3;
                }
                c0316ciJ = this.AudioAttributesCompatParcelizer;
            }
            return c0316ciJ;
        }
    }

    private static C0061bRv setError(bRE bre) throws CertificateParsingException {
        try {
            byte[] options = AbstractC0317ciK.setOptions(bre, "2.5.29.19");
            if (options == null) {
                return null;
            }
            return C0061bRv.setLabel(bNe.setElement(options));
        } catch (Exception e) {
            throw new CertificateParsingException("cannot construct BasicConstraints: " + e);
        }
    }

    private static String setFieldValue(bRE bre) throws CertificateParsingException {
        try {
            return C0318ciL.setError(bre.setOptions());
        } catch (Exception e) {
            throw new CertificateParsingException("cannot construct SigAlgName: " + e);
        }
    }

    private static byte[] setLabel(bRE bre) throws CertificateParsingException {
        try {
            bMM background = bre.setOptions().setBackground();
            if (background == null) {
                return null;
            }
            return background.AudioAttributesImplApi21Parcelizer().setOptions("DER");
        } catch (Exception e) {
            throw new CertificateParsingException("cannot construct SigAlgParams: " + e);
        }
    }

    private static boolean[] setOptions(bRE bre) throws CertificateParsingException {
        try {
            byte[] options = AbstractC0317ciK.setOptions(bre, "2.5.29.15");
            if (options == null) {
                return null;
            }
            bMG background = bMG.setBackground(bNe.setElement(options));
            byte[] fieldValue = background.setFieldValue();
            int length = (fieldValue.length * 8) - background.setElement();
            int i = 9;
            if (length >= 9) {
                i = length;
            }
            boolean[] zArr = new boolean[i];
            for (int i2 = 0; i2 != length; i2++) {
                zArr[i2] = (fieldValue[i2 / 8] & (128 >>> (i2 % 8))) != 0;
            }
            return zArr;
        } catch (Exception e) {
            throw new CertificateParsingException("cannot construct KeyUsage: " + e);
        }
    }

    @Override
    public void checkValidity(Date date) throws CertificateExpiredException, CertificateNotYetValidException {
        long time = date.getTime();
        long[] error = setError();
        if (time > error[1]) {
            throw new CertificateExpiredException("certificate expired on " + this.setError.setLabel().setError());
        }
        if (time >= error[0]) {
            return;
        }
        throw new CertificateNotYetValidException("certificate not valid till " + this.setError.read().setError());
    }

    @Override
    public boolean equals(Object obj) {
        C0316ciJ RemoteActionCompatParcelizer;
        bMG error;
        if (obj == this) {
            return true;
        }
        if (obj instanceof C0314ciH) {
            C0314ciH c0314ciH = (C0314ciH) obj;
            if (this.setElement && c0314ciH.setElement) {
                if (this.IconCompatParcelizer != c0314ciH.IconCompatParcelizer) {
                    return false;
                }
            } else if ((this.AudioAttributesCompatParcelizer == null || c0314ciH.AudioAttributesCompatParcelizer == null) && (error = this.setError.setError()) != null && !error.setLabel(c0314ciH.setError.setError())) {
                return false;
            }
            RemoteActionCompatParcelizer = RemoteActionCompatParcelizer();
            obj = c0314ciH.RemoteActionCompatParcelizer();
        } else {
            RemoteActionCompatParcelizer = RemoteActionCompatParcelizer();
        }
        return RemoteActionCompatParcelizer.equals(obj);
    }

    @Override
    public byte[] getEncoded() throws CertificateEncodingException {
        return cEJ.setBackground(RemoteActionCompatParcelizer().getEncoded());
    }

    @Override
    public X500Principal getIssuerX500Principal() {
        X500Principal x500Principal;
        synchronized (this.write) {
            X500Principal x500Principal2 = this.AudioAttributesImplBaseParcelizer;
            if (x500Principal2 != null) {
                return x500Principal2;
            }
            X500Principal issuerX500Principal = super.getIssuerX500Principal();
            synchronized (this.write) {
                if (this.AudioAttributesImplBaseParcelizer == null) {
                    this.AudioAttributesImplBaseParcelizer = issuerX500Principal;
                }
                x500Principal = this.AudioAttributesImplBaseParcelizer;
            }
            return x500Principal;
        }
    }

    @Override
    public PublicKey getPublicKey() {
        PublicKey publicKey;
        synchronized (this.write) {
            PublicKey publicKey2 = this.AudioAttributesImplApi21Parcelizer;
            if (publicKey2 != null) {
                return publicKey2;
            }
            PublicKey publicKey3 = super.getPublicKey();
            if (publicKey3 == null) {
                return null;
            }
            synchronized (this.write) {
                if (this.AudioAttributesImplApi21Parcelizer == null) {
                    this.AudioAttributesImplApi21Parcelizer = publicKey3;
                }
                publicKey = this.AudioAttributesImplApi21Parcelizer;
            }
            return publicKey;
        }
    }

    @Override
    public X500Principal getSubjectX500Principal() {
        X500Principal x500Principal;
        synchronized (this.write) {
            X500Principal x500Principal2 = this.MediaBrowserCompatCustomActionResultReceiver;
            if (x500Principal2 != null) {
                return x500Principal2;
            }
            X500Principal subjectX500Principal = super.getSubjectX500Principal();
            synchronized (this.write) {
                if (this.MediaBrowserCompatCustomActionResultReceiver == null) {
                    this.MediaBrowserCompatCustomActionResultReceiver = subjectX500Principal;
                }
                x500Principal = this.MediaBrowserCompatCustomActionResultReceiver;
            }
            return x500Principal;
        }
    }

    @Override
    public int hashCode() {
        if (!this.setElement) {
            this.IconCompatParcelizer = RemoteActionCompatParcelizer().hashCode();
            this.setElement = true;
        }
        return this.IconCompatParcelizer;
    }

    public int setBackground() {
        try {
            byte[] encoded = RemoteActionCompatParcelizer().getEncoded();
            int i = 0;
            for (int i2 = 1; i2 < encoded.length; i2++) {
                i += encoded[i2] * i2;
            }
            return i;
        } catch (CertificateEncodingException unused) {
            return 0;
        }
    }

    @Override
    public void setBackground(bNc bnc, bMM bmm) {
        this.read.setBackground(bnc, bmm);
    }

    @Override
    public bMM setError(bNc bnc) {
        return this.read.setError(bnc);
    }

    public long[] setError() {
        long[] jArr;
        synchronized (this.write) {
            long[] jArr2 = this.AudioAttributesImplApi26Parcelizer;
            if (jArr2 != null) {
                return jArr2;
            }
            long[] jArr3 = {super.getNotBefore().getTime(), super.getNotAfter().getTime()};
            synchronized (this.write) {
                if (this.AudioAttributesImplApi26Parcelizer == null) {
                    this.AudioAttributesImplApi26Parcelizer = jArr3;
                }
                jArr = this.AudioAttributesImplApi26Parcelizer;
            }
            return jArr;
        }
    }

    @Override
    public Enumeration setOptions() {
        return this.read.setOptions();
    }
}