Java 类javax.net.ssl.X509ExtendedTrustManager 实例源码

@SuppressWarnings("unused")
@Test
public void testConstructor() {
  String keyStoreName = custom.getFullPath(option.getKeyStore());
  char[] keyStoreValue = custom.decode(option.getKeyStoreValue().toCharArray());
  String trustStoreName = custom.getFullPath(option.getTrustStore());
  char[] trustStoreValue =
      custom.decode(option.getTrustStoreValue().toCharArray());
  KeyStore trustStore =
      KeyStoreUtil.createKeyStore(trustStoreName,
          option.getTrustStoreType(),
          trustStoreValue);
  TrustManager[] trustManager = KeyStoreUtil.createTrustManagers(trustStore);

  TrustManagerExt trustManagerExt = new TrustManagerExt((X509ExtendedTrustManager) trustManager[0],
      option, custom);
  Assert.assertEquals(3, trustManagerExt.getAcceptedIssuers()[0].getVersion());
  Assert.assertNotNull(trustManagerExt);
}

@Override
protected final TrustManager[] engineGetTrustManagers() {
    List<X509ExtendedTrustManager> delegates = new ArrayList<>();

    X509ExtendedTrustManager systemTrustManager = getSystemTrustManager();
    if (systemTrustManager != null) {
        delegates.add(systemTrustManager);
    }

    FileWatchingX509ExtendedTrustManager containerTrustManager = getContainerTrustManager();
    if (containerTrustManager != null) {
        delegates.add(containerTrustManager);
    }

    return new TrustManager[]{new DelegatingX509ExtendedTrustManager(delegates)};
}

private void with(Consumer consumer) throws CertificateException {
    CertificateException exception = null;

    for (X509ExtendedTrustManager delegate : this.delegates) {
        try {
            consumer.accept(delegate);
            return;
        } catch (CertificateException e) {
            exception = e;
        }
    }

    if (exception != null) {
        throw exception;
    }
}

/**
 * Create a {@link TrustManager} that validates server certificates against this trust store.
 * The returned trust manager is configured to throw a {@link NotTrustedException} with the
 * certificates presented by the server if they are not trusted.
 * 
 * @return the trust manager
 * @throws GeneralSecurityException
 */
public TrustManager createTrustManager() {
    try {
        KeyStore trustStore = getTrustStore();
        if (trustStore.aliases().hasMoreElements()) {
            TrustManagerFactory tmfactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            tmfactory.init(trustStore);
            TrustManager[] trustManagers = tmfactory.getTrustManagers();
            if (trustManagers.length != 1) {
                throw new RuntimeException("Expected a TrustManager array with a single entry");
            }
            return new TrustManagerWrapper((X509ExtendedTrustManager)trustManagers[0]);
        } else {
            return new NoTrustManager();
        }
    } catch (GeneralSecurityException ex) {
        throw new TrustStoreError(ex);
    }
}

private X509ExtendedTrustManager getTrustManager(KeyStore keyStore) {
    try {
        this.trustManagerFactory.init(keyStore);

        for (TrustManager trustManager : this.trustManagerFactory.getTrustManagers()) {
            if (trustManager instanceof X509ExtendedTrustManager) {
                return (X509ExtendedTrustManager) trustManager;
            }
        }

        throw new IllegalStateException("No X509ExtendedTrustManager available");
    } catch (KeyStoreException e) {
        throw new UndeclaredThrowableException(e);
    }
}

private X509ExtendedTrustManager getSystemTrustManager() {
    synchronized (MONITOR) {
        if (this.cachedSystemTrustManager == null) {
            for (TrustManager candidate : this.systemTrustManagerFactory.getTrustManagers()) {
                if (candidate instanceof X509ExtendedTrustManager) {
                    this.logger.info("Adding System Trust Manager");
                    this.cachedSystemTrustManager = (X509ExtendedTrustManager) candidate;
                    break;
                }
            }
        }

        return this.cachedSystemTrustManager;
    }
}

@Override
public void checkClientTrusted(final X509Certificate[] x509Certificates, final String s, final Socket socket) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkClientTrusted(x509Certificates, s, socket);
        }

    });
}

@Override
public void checkClientTrusted(final X509Certificate[] x509Certificates, final String s) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkClientTrusted(x509Certificates, s);
        }

    });
}

@Override
public void checkClientTrusted(final X509Certificate[] x509Certificates, final String s, final SSLEngine sslEngine) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkClientTrusted(x509Certificates, s, sslEngine);
        }

    });
}

@Override
public void checkServerTrusted(final X509Certificate[] x509Certificates, final String s, final Socket socket) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkServerTrusted(x509Certificates, s, socket);
        }

    });
}

@Override
public void checkServerTrusted(final X509Certificate[] x509Certificates, final String s) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkServerTrusted(x509Certificates, s);
        }

    });
}

@Override
public void checkServerTrusted(final X509Certificate[] x509Certificates, final String s, final SSLEngine sslEngine) throws CertificateException {
    with(new Consumer() {

        @Override
        public void accept(X509ExtendedTrustManager delegate) throws CertificateException {
            delegate.checkServerTrusted(x509Certificates, s, sslEngine);
        }

    });
}

@Override
public X509Certificate[] getAcceptedIssuers() {
    return collect(new Function() {

        @Override
        public X509Certificate[] apply(X509ExtendedTrustManager delegate) {
            return delegate.getAcceptedIssuers();
        }

    });
}

private X509Certificate[] collect(Function function) {
    List<X509Certificate> collected = new ArrayList<>();

    for (X509ExtendedTrustManager delegate : this.delegates) {
        X509Certificate[] candidate = function.apply(delegate);
        if (candidate != null) {
            Collections.addAll(collected, candidate);
        }
    }

    return collected.toArray(new X509Certificate[collected.size()]);

}

static void checkClientTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        AbstractConscryptSocket socket) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkClientTrusted(chain, authType, socket);
    } else if (!checkTrusted("checkClientTrusted", tm, chain, authType, Socket.class, socket)
            && !checkTrusted("checkClientTrusted", tm, chain, authType, String.class,
                       socket.getHandshakeSession().getPeerHost())) {
        tm.checkClientTrusted(chain, authType);
    }
}

static void checkServerTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        AbstractConscryptSocket socket) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkServerTrusted(chain, authType, socket);
    } else if (!checkTrusted("checkServerTrusted", tm, chain, authType, Socket.class, socket)
            && !checkTrusted("checkServerTrusted", tm, chain, authType, String.class,
                       socket.getHandshakeSession().getPeerHost())) {
        tm.checkServerTrusted(chain, authType);
    }
}

static void checkClientTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        ConscryptEngine engine) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkClientTrusted(chain, authType, engine);
    } else if (!checkTrusted("checkClientTrusted", tm, chain, authType, SSLEngine.class, engine)
            && !checkTrusted("checkClientTrusted", tm, chain, authType, String.class,
                       engine.getHandshakeSession().getPeerHost())) {
        tm.checkClientTrusted(chain, authType);
    }
}

static void checkServerTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        ConscryptEngine engine) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkServerTrusted(chain, authType, engine);
    } else if (!checkTrusted("checkServerTrusted", tm, chain, authType, SSLEngine.class, engine)
            && !checkTrusted("checkServerTrusted", tm, chain, authType, String.class,
                       engine.getHandshakeSession().getPeerHost())) {
        tm.checkServerTrusted(chain, authType);
    }
}

static void checkClientTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        AbstractConscryptSocket socket) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkClientTrusted(chain, authType, socket);
    } else {
        tm.checkClientTrusted(chain, authType);
    }
}

static void checkServerTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        AbstractConscryptSocket socket) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkServerTrusted(chain, authType, socket);
    } else {
        tm.checkServerTrusted(chain, authType);
    }
}

static void checkClientTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        ConscryptEngine engine) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkClientTrusted(chain, authType, engine);
    } else {
        tm.checkClientTrusted(chain, authType);
    }
}

static void checkServerTrusted(X509TrustManager tm, X509Certificate[] chain, String authType,
        ConscryptEngine engine) throws CertificateException {
    if (tm instanceof X509ExtendedTrustManager) {
        X509ExtendedTrustManager x509etm = (X509ExtendedTrustManager) tm;
        x509etm.checkServerTrusted(chain, authType, engine);
    } else {
        tm.checkServerTrusted(chain, authType);
    }
}

public static TrustManager wrap(TrustManager trustManager) {
    if (EXTENDED_TRUST_MANAGER_CLASS != null && EXTENDED_TRUST_MANAGER_CLASS.isInstance(trustManager)) {
        return new ExtendedWrapper((X509ExtendedTrustManager) trustManager);
    } else if (trustManager instanceof X509TrustManager) {
        return new Wrapper((X509TrustManager) trustManager);
    }
    return trustManager;
}

@Test
public void testTrustManagerProxyCheckClientTrusted(@Mocked X509ExtendedTrustManager mockedTrustManager) throws CertificateException {
    new Expectations() {{
        mockedTrustManager.checkClientTrusted((X509Certificate[]) any, "cert"); times = 1;
    }};

    TrustManagerProxy trustManagerProxy = new TrustManagerProxy(new TrustManager[]{mockedTrustManager});
    trustManagerProxy.checkClientTrusted(null, "cert");
}

@Test
public void testTrustManagerProxyCheckServerTrusted(@Mocked X509ExtendedTrustManager mockedTrustManager) throws CertificateException {
    new Expectations() {{
        mockedTrustManager.checkServerTrusted((X509Certificate[]) any, "cert"); times = 1;
    }};

    TrustManagerProxy trustManagerProxy = new TrustManagerProxy(new TrustManager[]{mockedTrustManager});

    trustManagerProxy.checkServerTrusted(null, "cert");
}

@Test
public void testTrustManagerProxyGetAcceptedIssuers(@Mocked X509ExtendedTrustManager mockedTrustManager) throws CertificateException {
    new Expectations() {{
        mockedTrustManager.getAcceptedIssuers(); times = 1; result = null;
    }};

    TrustManagerProxy trustManagerProxy = new TrustManagerProxy(new TrustManager[]{mockedTrustManager});
    assertNull(trustManagerProxy.getAcceptedIssuers());
}

private static X509ExtendedTrustManager getX509TrustManager(TrustManager trustManager) throws StartException {
    if (trustManager == null) {
        return null;
    }
    if (trustManager instanceof X509ExtendedTrustManager) {
        return (X509ExtendedTrustManager) trustManager;
    }
    throw ROOT_LOGGER.invalidTypeInjected(X509ExtendedTrustManager.class.getSimpleName());
}

public TrustManagerExt(X509ExtendedTrustManager manager, SSLOption option,
    SSLCustom custom) {
  this.trustManager = manager;
  this.option = option;
  this.custom = custom;
}

DelegatingX509ExtendedTrustManager(List<X509ExtendedTrustManager> delegates) {
    this.delegates = delegates;
}

ExtendedWrapper(X509ExtendedTrustManager trustManager) {
    out.println("TestTrustManager.<init> extendedTrustManager=" + trustManager);
    this.extendedTrustManager = trustManager;
    this.trustManager = trustManager;
}

X509ExtendedTrustManagerProxy(X509ExtendedTrustManager trustManager) {
  this.trustManager = trustManager;
}

public TrackingTrustManager(X509TrustManager trustManager, TealessSSLContextBuilder.SSLCertificateVerificationTracker tracker) {
  super((X509ExtendedTrustManager) trustManager);
  this.tracker = tracker;
}

static boolean useExtendedTrustManager(X509TrustManager trustManager) {
     return PlatformDependent.javaVersion() >= 7 && trustManager instanceof X509ExtendedTrustManager;
}

/**
 * overwrites the existing key manager.
 * @param trustManagers only the first element will be used, and MUST be a X509ExtendedTrustManager
 */
public void setTrustManager(final TrustManager[] trustManagers) {
    trustManager = (X509ExtendedTrustManager) trustManagers[0];
}

void accept(X509ExtendedTrustManager delegate) throws CertificateException;

X509Certificate[] apply(X509ExtendedTrustManager delegate);