275 lines
14 KiB
Java
275 lines
14 KiB
Java
package o;
|
|
|
|
import java.security.InvalidAlgorithmParameterException;
|
|
import java.security.PublicKey;
|
|
import java.security.cert.CertPath;
|
|
import java.security.cert.CertPathParameters;
|
|
import java.security.cert.CertPathValidatorException;
|
|
import java.security.cert.CertPathValidatorResult;
|
|
import java.security.cert.CertPathValidatorSpi;
|
|
import java.security.cert.Certificate;
|
|
import java.security.cert.PKIXCertPathChecker;
|
|
import java.security.cert.PKIXCertPathValidatorResult;
|
|
import java.security.cert.PKIXParameters;
|
|
import java.security.cert.TrustAnchor;
|
|
import java.security.cert.X509Certificate;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import o.C15457gqz;
|
|
import org.bouncycastle.jce.provider.RFC3280CertPathUtilities;
|
|
import org.spongycastle.jce.exception.ExtCertPathValidatorException;
|
|
import org.spongycastle.jce.provider.AnnotatedException;
|
|
|
|
/* renamed from: o.grk, reason: case insensitive filesystem */
|
|
/* loaded from: classes6.dex */
|
|
public class C15483grk extends CertPathValidatorSpi {
|
|
private final gqQ e = new gqR();
|
|
|
|
@Override // java.security.cert.CertPathValidatorSpi
|
|
public CertPathValidatorResult engineValidate(CertPath certPath, CertPathParameters certPathParameters) throws CertPathValidatorException, InvalidAlgorithmParameterException {
|
|
C15457gqz c15457gqz;
|
|
C15417gpt c;
|
|
PublicKey cAPublicKey;
|
|
HashSet hashSet;
|
|
int i;
|
|
List<PKIXCertPathChecker> list;
|
|
ArrayList[] arrayListArr;
|
|
HashSet hashSet2;
|
|
int i2;
|
|
C15483grk c15483grk = this;
|
|
if (certPathParameters instanceof PKIXParameters) {
|
|
C15457gqz.LWm lWm = new C15457gqz.LWm((PKIXParameters) certPathParameters);
|
|
if (certPathParameters instanceof C15472grZ) {
|
|
C15472grZ c15472grZ = (C15472grZ) certPathParameters;
|
|
lWm.i = c15472grZ.i;
|
|
lWm.f9150o = c15472grZ.g;
|
|
}
|
|
c15457gqz = new C15457gqz(lWm, (byte) 0);
|
|
} else if (!(certPathParameters instanceof gqA)) {
|
|
if (certPathParameters instanceof C15457gqz) {
|
|
c15457gqz = (C15457gqz) certPathParameters;
|
|
} else {
|
|
StringBuilder sb = new StringBuilder("Parameters must be a ");
|
|
sb.append(PKIXParameters.class.getName());
|
|
sb.append(" instance.");
|
|
throw new InvalidAlgorithmParameterException(sb.toString());
|
|
}
|
|
} else {
|
|
c15457gqz = ((gqA) certPathParameters).e;
|
|
}
|
|
if (c15457gqz.i == null) {
|
|
throw new InvalidAlgorithmParameterException("trustAnchors is null, this is not allowed for certification path validation.");
|
|
}
|
|
List<? extends Certificate> certificates = certPath.getCertificates();
|
|
int size = certificates.size();
|
|
if (certificates.isEmpty()) {
|
|
throw new CertPathValidatorException("Certification path is empty.", null, certPath, -1);
|
|
}
|
|
Set<String> initialPolicies = c15457gqz.b.getInitialPolicies();
|
|
try {
|
|
TrustAnchor e = C15473gra.e((X509Certificate) certificates.get(certificates.size() - 1), c15457gqz.i, c15457gqz.b.getSigProvider());
|
|
if (e == null) {
|
|
throw new CertPathValidatorException("Trust anchor for certification path not found.", null, certPath, -1);
|
|
}
|
|
C15457gqz.LWm lWm2 = new C15457gqz.LWm(c15457gqz);
|
|
lWm2.g = Collections.singleton(e);
|
|
C15457gqz c15457gqz2 = new C15457gqz(lWm2, (byte) 0);
|
|
int i3 = size + 1;
|
|
ArrayList[] arrayListArr2 = new ArrayList[i3];
|
|
for (int i4 = 0; i4 < i3; i4++) {
|
|
arrayListArr2[i4] = new ArrayList();
|
|
}
|
|
HashSet hashSet3 = new HashSet();
|
|
hashSet3.add(RFC3280CertPathUtilities.ANY_POLICY);
|
|
C15485grm c15485grm = new C15485grm(new ArrayList(), 0, hashSet3, null, new HashSet(), RFC3280CertPathUtilities.ANY_POLICY, false);
|
|
arrayListArr2[0].add(c15485grm);
|
|
C15486grn c15486grn = new C15486grn();
|
|
HashSet hashSet4 = new HashSet();
|
|
int i5 = c15457gqz2.b.isExplicitPolicyRequired() ? 0 : i3;
|
|
int i6 = c15457gqz2.b.isAnyPolicyInhibited() ? 0 : i3;
|
|
if (c15457gqz2.b.isPolicyMappingInhibited()) {
|
|
i3 = 0;
|
|
}
|
|
X509Certificate trustedCert = e.getTrustedCert();
|
|
try {
|
|
if (trustedCert != null) {
|
|
c = C15417gpt.c(trustedCert.getSubjectX500Principal().getEncoded());
|
|
cAPublicKey = trustedCert.getPublicKey();
|
|
} else {
|
|
c = C15417gpt.c(e.getCA().getEncoded());
|
|
cAPublicKey = e.getCAPublicKey();
|
|
}
|
|
try {
|
|
C15423gpz b = C15473gra.b(cAPublicKey);
|
|
C15314gnC c15314gnC = b.e;
|
|
InterfaceC15342gnr interfaceC15342gnr = b.a;
|
|
if (c15457gqz2.g != null) {
|
|
if (!c15457gqz2.g.b.match((X509Certificate) certificates.get(0))) {
|
|
throw new ExtCertPathValidatorException("Target certificate in certification path does not match targetConstraints.", null, certPath, 0);
|
|
}
|
|
}
|
|
List<PKIXCertPathChecker> certPathCheckers = c15457gqz2.b.getCertPathCheckers();
|
|
Iterator<PKIXCertPathChecker> it = certPathCheckers.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().init(false);
|
|
i3 = i3;
|
|
}
|
|
int i7 = i3;
|
|
X509Certificate x509Certificate = trustedCert;
|
|
int i8 = i6;
|
|
int i9 = size;
|
|
PublicKey publicKey = cAPublicKey;
|
|
int size2 = certificates.size() - 1;
|
|
C15417gpt c15417gpt = c;
|
|
X509Certificate x509Certificate2 = null;
|
|
C15485grm c15485grm2 = c15485grm;
|
|
int i10 = i7;
|
|
while (size2 >= 0) {
|
|
X509Certificate x509Certificate3 = (X509Certificate) certificates.get(size2);
|
|
boolean z = size2 == certificates.size() + (-1);
|
|
gqQ gqq = c15483grk.e;
|
|
int i11 = i8;
|
|
List<? extends Certificate> list2 = certificates;
|
|
int i12 = i5;
|
|
Set<String> set = initialPolicies;
|
|
int i13 = i10;
|
|
C15457gqz c15457gqz3 = c15457gqz2;
|
|
C15486grn c15486grn2 = c15486grn;
|
|
boolean z2 = z;
|
|
ArrayList[] arrayListArr3 = arrayListArr2;
|
|
TrustAnchor trustAnchor = e;
|
|
int i14 = size2;
|
|
List<PKIXCertPathChecker> list3 = certPathCheckers;
|
|
C15492grt.c(certPath, c15457gqz2, size2, publicKey, z2, c15417gpt, x509Certificate, gqq);
|
|
C15492grt.a(certPath, i14, c15486grn2);
|
|
C15485grm e2 = C15492grt.e(certPath, i14, C15492grt.d(certPath, i14, hashSet4, c15485grm2, arrayListArr3, i11));
|
|
C15492grt.a(certPath, i14, e2, i12);
|
|
if (size - i14 == size) {
|
|
i = i14;
|
|
list = list3;
|
|
arrayListArr = arrayListArr3;
|
|
c15483grk = this;
|
|
c15485grm2 = e2;
|
|
i8 = i11;
|
|
i5 = i12;
|
|
i10 = i13;
|
|
} else {
|
|
if (x509Certificate3 != null && x509Certificate3.getVersion() == 1) {
|
|
throw new CertPathValidatorException("Version 1 certificates can't be used as CA ones.", null, certPath, i14);
|
|
}
|
|
C15492grt.e(certPath, i14);
|
|
arrayListArr = arrayListArr3;
|
|
C15485grm b2 = C15492grt.b(certPath, i14, arrayListArr, e2, i13);
|
|
C15492grt.c(certPath, i14, c15486grn2);
|
|
int e3 = C15492grt.e(certPath, i14, i12);
|
|
int d = C15492grt.d(certPath, i14, i13);
|
|
int b3 = C15492grt.b(certPath, i14, i11);
|
|
int a = C15492grt.a(certPath, i14, e3);
|
|
int c2 = C15492grt.c(certPath, i14, d);
|
|
int g = C15492grt.g(certPath, i14, b3);
|
|
C15492grt.b(certPath, i14);
|
|
i9 = C15492grt.i(certPath, i14, C15492grt.h(certPath, i14, i9));
|
|
C15492grt.d(certPath, i14);
|
|
Set<String> criticalExtensionOIDs = x509Certificate3.getCriticalExtensionOIDs();
|
|
if (criticalExtensionOIDs != null) {
|
|
hashSet2 = new HashSet(criticalExtensionOIDs);
|
|
hashSet2.remove(C15492grt.h);
|
|
hashSet2.remove(C15492grt.d);
|
|
hashSet2.remove(C15492grt.i);
|
|
hashSet2.remove(C15492grt.a);
|
|
hashSet2.remove(C15492grt.j);
|
|
hashSet2.remove(C15492grt.e);
|
|
hashSet2.remove(C15492grt.g);
|
|
hashSet2.remove(C15492grt.c);
|
|
hashSet2.remove(C15492grt.l);
|
|
hashSet2.remove(C15492grt.f);
|
|
} else {
|
|
hashSet2 = new HashSet();
|
|
}
|
|
list = list3;
|
|
C15492grt.d(certPath, i14, hashSet2, list);
|
|
C15417gpt c3 = C15417gpt.c(x509Certificate3.getSubjectX500Principal().getEncoded());
|
|
try {
|
|
i2 = i14;
|
|
c15483grk = this;
|
|
try {
|
|
PublicKey c4 = C15473gra.c(certPath.getCertificates(), i2, c15483grk.e);
|
|
C15423gpz b4 = C15473gra.b(c4);
|
|
C15314gnC c15314gnC2 = b4.e;
|
|
InterfaceC15342gnr interfaceC15342gnr2 = b4.a;
|
|
c15485grm2 = b2;
|
|
c15417gpt = c3;
|
|
publicKey = c4;
|
|
i = i2;
|
|
x509Certificate = x509Certificate3;
|
|
i5 = a;
|
|
i8 = g;
|
|
i10 = c2;
|
|
} catch (CertPathValidatorException e4) {
|
|
e = e4;
|
|
throw new CertPathValidatorException("Next working key could not be retrieved.", e, certPath, i2);
|
|
}
|
|
} catch (CertPathValidatorException e5) {
|
|
e = e5;
|
|
i2 = i14;
|
|
}
|
|
}
|
|
size2 = i - 1;
|
|
certPathCheckers = list;
|
|
x509Certificate2 = x509Certificate3;
|
|
certificates = list2;
|
|
initialPolicies = set;
|
|
e = trustAnchor;
|
|
arrayListArr2 = arrayListArr;
|
|
c15486grn = c15486grn2;
|
|
c15457gqz2 = c15457gqz3;
|
|
}
|
|
C15457gqz c15457gqz4 = c15457gqz2;
|
|
ArrayList[] arrayListArr4 = arrayListArr2;
|
|
TrustAnchor trustAnchor2 = e;
|
|
List<PKIXCertPathChecker> list4 = certPathCheckers;
|
|
Set<String> set2 = initialPolicies;
|
|
int i15 = size2;
|
|
int i16 = i15 + 1;
|
|
int j = C15492grt.j(certPath, i16, C15492grt.a(i5, x509Certificate2));
|
|
Set<String> criticalExtensionOIDs2 = x509Certificate2.getCriticalExtensionOIDs();
|
|
if (criticalExtensionOIDs2 != null) {
|
|
hashSet = new HashSet(criticalExtensionOIDs2);
|
|
hashSet.remove(C15492grt.h);
|
|
hashSet.remove(C15492grt.d);
|
|
hashSet.remove(C15492grt.i);
|
|
hashSet.remove(C15492grt.a);
|
|
hashSet.remove(C15492grt.j);
|
|
hashSet.remove(C15492grt.e);
|
|
hashSet.remove(C15492grt.g);
|
|
hashSet.remove(C15492grt.c);
|
|
hashSet.remove(C15492grt.l);
|
|
hashSet.remove(C15492grt.f);
|
|
hashSet.remove(C15492grt.b);
|
|
hashSet.remove(C15394gpK.g.d);
|
|
} else {
|
|
hashSet = new HashSet();
|
|
}
|
|
C15492grt.e(certPath, i16, list4, hashSet);
|
|
X509Certificate x509Certificate4 = x509Certificate2;
|
|
C15485grm b5 = C15492grt.b(certPath, c15457gqz4, set2, i16, arrayListArr4, c15485grm2, hashSet4);
|
|
if (j > 0 || b5 != null) {
|
|
return new PKIXCertPathValidatorResult(trustAnchor2, b5, x509Certificate4.getPublicKey());
|
|
}
|
|
throw new CertPathValidatorException("Path processing failed on policy.", null, certPath, i15);
|
|
} catch (CertPathValidatorException e6) {
|
|
throw new ExtCertPathValidatorException("Algorithm identifier of public key of trust anchor could not be read.", e6, certPath, -1);
|
|
}
|
|
} catch (IllegalArgumentException e7) {
|
|
throw new ExtCertPathValidatorException("Subject of trust anchor could not be (re)encoded.", e7, certPath, -1);
|
|
}
|
|
} catch (AnnotatedException e8) {
|
|
throw new CertPathValidatorException(e8.getMessage(), e8, certPath, certificates.size() - 1);
|
|
}
|
|
}
|
|
}
|