How to use

setSecureScheme

method

in

org.eclipse.jetty.server.HttpConfiguration

private static HttpConnectionFactory createHttpConnectionFactory() {
  HttpConfiguration httpConfig = new HttpConfiguration();
  httpConfig.setSecureScheme("https");
  httpConfig.addCustomizer(new ForwardedRequestCustomizer());
  return new HttpConnectionFactory(httpConfig);
}

private ServerConnector createConnector(final SslContextFactory sslContextFactory, final Integer listenPort) {
  final ServerConnector serverConnector;
  if (sslContextFactory == null) {
    serverConnector = new ServerConnector(server);
  } else {
    final HttpConfiguration httpsConfiguration = new HttpConfiguration();
    httpsConfiguration.setSecureScheme("https");
    httpsConfiguration.addCustomizer(new SecureRequestCustomizer());
    serverConnector = new ServerConnector(server,
        new SslConnectionFactory(sslContextFactory, "http/1.1"),
        new HttpConnectionFactory(httpsConfiguration));
  }
  serverConnector.setPort(listenPort);
  return serverConnector;
}

private ServerConnector createConnector(Server server,
    SslContextFactory sslContextFactory, InetSocketAddress address) {
  HttpConfiguration config = new HttpConfiguration();
  config.setSendServerVersion(false);
  config.setSecureScheme("https");
  config.setSecurePort(address.getPort());
  config.addCustomizer(new SecureRequestCustomizer());
  ServerConnector connector = createServerConnector(server, sslContextFactory,
      config);
  connector.setPort(address.getPort());
  connector.setHost(address.getHostString());
  return connector;
}

private ServerConnector createUnconfiguredSslServerConnector(Server server, HttpConfiguration httpConfiguration, int port) {
  // add some secure config
  final HttpConfiguration httpsConfiguration = new HttpConfiguration(httpConfiguration);
  httpsConfiguration.setSecureScheme("https");
  httpsConfiguration.setSecurePort(port);
  httpsConfiguration.addCustomizer(new SecureRequestCustomizer());
  // build the connector
  return new ServerConnector(server,
      new SslConnectionFactory(createSslContextFactory(), "http/1.1"),
      new HttpConnectionFactory(httpsConfiguration));
}

@Override
protected HttpConfiguration buildHttpConfiguration() {
  final HttpConfiguration config = super.buildHttpConfiguration();
  config.setSecureScheme("https");
  config.setSecurePort(getPort());
  config.addCustomizer(new SecureRequestCustomizer());
  return config;
}

final HttpConfiguration config = new HttpConfiguration();
if (sslContextFactory != null) {
  config.setSecureScheme("https");
  config.setSecurePort(port);
  config.addCustomizer(new SecureRequestCustomizer());

/**
 * Create ssl connector if https is used
 * @return
 */
private ServerConnector sslConnector() {
  HttpConfiguration http_config = new HttpConfiguration();
  http_config.setSecureScheme("https");
  http_config.setSecurePort(this.getPort());
  
  HttpConfiguration https_config = new HttpConfiguration(http_config);
  https_config.addCustomizer(new SecureRequestCustomizer());
  
  SslContextFactory sslContextFactory = new SslContextFactory(this.getCertKeyStorePath());
  sslContextFactory.setKeyStorePassword(this.getCertKeyStorePassword());
  //exclude weak ciphers
  sslContextFactory.setExcludeCipherSuites("^.*_(MD5|SHA|SHA1)$");
  //only support tlsv1.2
  sslContextFactory.addExcludeProtocols("SSL", "SSLv2", "SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.1");
  
  ServerConnector connector = new ServerConnector(jettyServer, 
      new SslConnectionFactory(sslContextFactory, "http/1.1"),
      new HttpConnectionFactory(https_config));
  connector.setPort(this.getPort());
  connector.setIdleTimeout(50000);
  return connector;
}

http_config.setSecureScheme("https");
http_config.setSecurePort(Integer.parseInt(globalProps.getProperty("serverPort")));

public static ServerConnector addHttpsConnector(Server server) throws IOException, URISyntaxException {
 String keyStoreFile = resourceAsFile("ssltest-keystore.jks").getAbsolutePath();
 SslContextFactory sslContextFactory = new SslContextFactory(keyStoreFile);
 sslContextFactory.setKeyStorePassword("changeit");
 String trustStoreFile = resourceAsFile("ssltest-cacerts.jks").getAbsolutePath();
 sslContextFactory.setTrustStorePath(trustStoreFile);
 sslContextFactory.setTrustStorePassword("changeit");
 HttpConfiguration httpsConfig = new HttpConfiguration();
 httpsConfig.setSecureScheme("https");
 httpsConfig.addCustomizer(new SecureRequestCustomizer());
 ServerConnector connector = new ServerConnector(server, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig));
 server.addConnector(connector);
 return connector;
}

String scheme = ep.getScheme();
HttpConfiguration httpConfig = new HttpConfiguration();
httpConfig.setSecureScheme("https");
httpConfig.setHeaderCacheSize(DEFAULT_MAX_HEADER_SIZE);
httpConfig.setResponseHeaderSize(DEFAULT_MAX_HEADER_SIZE);

httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(listenPort);
httpConfig.setHeaderCacheSize(DEFAULT_HTTP_MAX_HEADER_SIZE);

httpConfiguration.setSecureScheme("https");

HttpConfiguration httpCfg = new HttpConfiguration();
httpCfg.setSecureScheme("https");
httpCfg.setSecurePort(8443);
httpCfg.setSendServerVersion(true);

private Connector createSSLConnector( final Server httpBindServer ) {
  final int securePort = getHttpBindSecurePort();
  try {
    final IdentityStore identityStore = XMPPServer.getInstance().getCertificateStoreManager().getIdentityStore( ConnectionType.BOSH_C2S );
    if (securePort > 0 && identityStore.getStore().aliases().hasMoreElements() ) {
      if ( !identityStore.containsDomainCertificate( ) ) {
        Log.warn("HTTP binding: Using certificates but they are not valid for the hosted domain");
      }
      final ConnectionManagerImpl connectionManager = ((ConnectionManagerImpl) XMPPServer.getInstance().getConnectionManager());
      final ConnectionConfiguration configuration = connectionManager.getListener( ConnectionType.BOSH_C2S, true ).generateConnectionConfiguration();
      final SslContextFactory sslContextFactory = new EncryptionArtifactFactory(configuration).getSslContextFactory();
      final HttpConfiguration httpsConfig = new HttpConfiguration();
      httpsConfig.setSecureScheme("https");
      httpsConfig.setSecurePort(securePort);
      configureProxiedConnector(httpsConfig);
      httpsConfig.addCustomizer(new SecureRequestCustomizer());
      final ServerConnector sslConnector = new ServerConnector(httpBindServer, new SslConnectionFactory(sslContextFactory, "http/1.1"), new HttpConnectionFactory(httpsConfig));
      sslConnector.setHost(getBindInterface());
      sslConnector.setPort(securePort);
      return sslConnector;
    }
  }
  catch (Exception e) {
    Log.error("Error creating SSL connector for Http bind", e);
  }
  return null;
}

httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(m_sslPort);
httpConfig.addCustomizer(new SecureRequestCustomizer());

httpConfig.setSecureScheme("https");
httpConfig.setSecurePort(sslPort);
httpConfig.setOutputBufferSize(32768);

httpConfig.setSecureScheme(HTTPS);
httpConfig.setSecurePort(port);

 private ServerConnector createHttpsChannelConnector(
   Server server, HttpConfiguration httpConfig) {
  httpConfig.setSecureScheme(HTTPS_SCHEME);
  httpConfig.addCustomizer(new SecureRequestCustomizer());
  ServerConnector conn = createHttpChannelConnector(server, httpConfig);
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setNeedClientAuth(needsClientAuth);
  sslContextFactory.setKeyManagerPassword(keyPassword);
  if (keyStore != null) {
   sslContextFactory.setKeyStorePath(keyStore);
   sslContextFactory.setKeyStoreType(keyStoreType);
   sslContextFactory.setKeyStorePassword(keyStorePassword);
  }
  if (trustStore != null) {
   sslContextFactory.setTrustStorePath(trustStore);
   sslContextFactory.setTrustStoreType(trustStoreType);
   sslContextFactory.setTrustStorePassword(trustStorePassword);
  }
  if(null != excludeCiphers && !excludeCiphers.isEmpty()) {
   sslContextFactory.setExcludeCipherSuites(
     StringUtils.getTrimmedStrings(excludeCiphers));
   LOG.info("Excluded Cipher List:" + excludeCiphers);
  }
  conn.addFirstConnectionFactory(new SslConnectionFactory(sslContextFactory,
    HttpVersion.HTTP_1_1.asString()));
  return conn;
 }
}

httpsConfig.setSecureScheme( "https" );
httpsConfig.setSecurePort( adminSecurePort );
httpsConfig.addCustomizer( new SecureRequestCustomizer() );

httpsConfiguration.setSecureScheme("https");
httpsConfiguration.setSecurePort(node.getTlsPort());
httpsConfiguration.addCustomizer(new SecureRequestCustomizer());