import sun.security.validator.ValidatorException; //导入依赖的package包/类
/**
 * Checks a validation failure to see if it failed for the reason we think
 * it should.  This comes in as an SSLException of some sort, but it
 * encapsulates a ValidatorException which in turn encapsulates the
 * CertPathValidatorException we are interested in.
 *
 * @param e the exception thrown at the top level
 * @param reason the underlying CertPathValidatorException BasicReason
 * we are expecting it to have.
 *
 * @return true if the reason matches up, false otherwise.
 */
static boolean checkClientValidationFailure(Exception e,
        BasicReason reason) {
    boolean result = false;

    if (e instanceof SSLException) {
        Throwable valExc = e.getCause();
        if (valExc instanceof sun.security.validator.ValidatorException) {
            Throwable cause = valExc.getCause();
            if (cause instanceof CertPathValidatorException) {
                CertPathValidatorException cpve =
                        (CertPathValidatorException)cause;
                if (cpve.getReason() == reason) {
                    result = true;
                }
            }
        }
    }
    return result;
}
 

import sun.security.validator.ValidatorException; //导入依赖的package包/类
/**
 * Check if client is trusted (no support for custom here, only system/user)
 * @param chain certificate chain
 * @param authType type of authentification
 * @param hostName hostnem
 * @throws java.security.cert.CertificateException if certificate is wrong
 */
public void checkTrustClient(X509Certificate[] chain, String authType,
                               String hostName)
        throws CertificateException {

    boolean trusted = false;
    ValidatorException savedException = null;
    for (X509TrustManager clientTrustManager : clientTrustManagers) {
        try {
            clientTrustManager.checkClientTrusted(chain, authType);
            trusted = true;
            break;
        }catch (ValidatorException caex) {
            savedException = caex;
        }
    }
    if (trusted) {
        return;
    }

    throw savedException;
}
 

import sun.security.validator.ValidatorException; //导入依赖的package包/类
/**
 * Return if the user explicitly trusted this i.e. in userTrustManager or temporarilyTrusted
 */
private boolean isExplicitlyTrusted(X509Certificate[] chain, String authType) {
    boolean explicitlyTrusted = false;

    for (X509TrustManager certTrustManager : certTrustManagers) {
        try {
            certTrustManager.checkServerTrusted(chain, authType);
            explicitlyTrusted = true;
            break;
        }catch (ValidatorException uex) {
            if (temporarilyTrusted.contains(chain[0])) {
                explicitlyTrusted = true;
                break;
            }
        }catch (CertificateException ce) {
            // not explicitly trusted
        }
    }

    return explicitlyTrusted;
}
 

import sun.security.validator.ValidatorException; //导入依赖的package包/类
void validateCertChain(List<? extends Certificate> certs) throws Exception {
    try {
        Validator.getInstance(Validator.TYPE_PKIX,
                Validator.VAR_CODE_SIGNING,
                pkixParameters)
                .validate(certs.toArray(new X509Certificate[certs.size()]));
    } catch (Exception e) {
        if (debug) {
            e.printStackTrace();
        }
        if (e instanceof ValidatorException) {
            // Throw cause if it's CertPathValidatorException,
            if (e.getCause() != null &&
                    e.getCause() instanceof CertPathValidatorException) {
                e = (Exception) e.getCause();
                Throwable t = e.getCause();
                if ((t instanceof CertificateExpiredException &&
                            hasExpiredCert) ||
                        (t instanceof CertificateNotYetValidException &&
                                notYetValidCert)) {
                    // we already have hasExpiredCert and notYetValidCert
                    return;
                }
            }
            if (e instanceof ValidatorException) {
                ValidatorException ve = (ValidatorException)e;
                if (ve.getErrorType() == ValidatorException.T_EE_EXTENSIONS &&
                        (badKeyUsage || badExtendedKeyUsage || badNetscapeCertType)) {
                    // We already have badKeyUsage, badExtendedKeyUsage
                    // and badNetscapeCertType
                    return;
                }
            }
        }
        throw e;
    }
}
 

import sun.security.validator.ValidatorException; //导入依赖的package包/类
public static boolean isCertificateException(IOException e) {
  return e.getCause() instanceof ValidatorException;
}