Example usage for javax.net.ssl SSLContext getSocketFactory

List of usage examples for javax.net.ssl SSLContext getSocketFactory

  1. HOME
  2. Java
  3. javax
  4. javax.net.ssl.*
  5. SSLContext
  6. getSocketFactory

Introduction

In this page you can find the example usage for javax.net.ssl SSLContext getSocketFactory.

Prototype

public final SSLSocketFactory getSocketFactory()

Source Link

Document

Returns a SocketFactory object for this context.

Usage

From source file:org.mifos.tools.provider.RestAdapterProvider.java

private OkHttpClient createClient() {

    final OkHttpClient client = new OkHttpClient();

    final TrustManager[] certs = new TrustManager[] { new X509TrustManager() {

        @Override/*www  .ja v a 2  s  .  c  om*/
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        @Override
        public void checkServerTrusted(final X509Certificate[] chain, final String authType)
                throws CertificateException {
        }

        @Override
        public void checkClientTrusted(final X509Certificate[] chain, final String authType)
                throws CertificateException {
        }
    } };

    SSLContext ctx = null;
    try {
        ctx = SSLContext.getInstance("TLS");
        ctx.init(null, certs, new SecureRandom());
    } catch (final java.security.GeneralSecurityException ex) {
        // do nothing, ignore
    }

    try {
        final HostnameVerifier hostnameVerifier = new HostnameVerifier() {
            @Override
            public boolean verify(final String hostname, final SSLSession session) {
                return true;
            }
        };
        client.setHostnameVerifier(hostnameVerifier);
        client.setSslSocketFactory(ctx.getSocketFactory());
    } catch (final Exception e) {
        // do nothing, ignore
    }

    return client;
}

From source file:org.bremersee.sms.GoyyaSmsService.java

/**
 * Creates the URL connection./*from   w w w .  j  a  va 2s  .  co  m*/
 * 
 * @param url
 *            the URL
 * @return the URL connection
 * @throws IOException
 *             if creation of the URL connection fails
 */
protected HttpURLConnection createHttpURLConnection(final String url) throws IOException {

    URL sendUrl = new URL(url);

    HttpURLConnection con = null;

    if (StringUtils.isNotBlank(proxyHost) && proxyPort != null) {

        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
        con = (HttpURLConnection) sendUrl.openConnection(proxy);
        if (StringUtils.isNotBlank(proxyUsername)) {
            String passwd = proxyPassword != null ? proxyPassword : "";
            String authValue = proxyUsername + ":" + passwd;
            String headerValue = Base64.encodeBase64String(authValue.getBytes("utf-8"));
            con.setRequestProperty("Proxy-Authorization", "Basic " + headerValue);
        }

    } else {

        con = (HttpURLConnection) sendUrl.openConnection();
    }

    try {
        if (url.toString().toLowerCase().startsWith("https")) {
            HttpsURLConnection secCon = (HttpsURLConnection) con;
            secCon.setHostnameVerifier(createAllHostnamesVerifier());
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, createTrustAllManagers(), new SecureRandom());
            secCon.setSSLSocketFactory(sc.getSocketFactory());
        }

    } catch (NoSuchAlgorithmException e) {
        IOException ise = new IOException(e);
        // log.error("Creating HttpURLConnection failed.", ise);
        throw ise;

    } catch (KeyManagementException e) {
        IOException ise = new IOException(e);
        // log.error("Creating HttpURLConnection failed.", ise);
        throw ise;
    }

    return con;
}

From source file:com.sitewhere.wso2.identity.scim.Wso2ScimAssetModule.java

protected SSLContext createContext() {
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }/*from   ww w.  ja v  a2 s . co  m*/

        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }

        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
        }
    } };

    try {
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, null);
        SSLContext.setDefault(sc);
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });
        return sc;

    } catch (Exception e) {
    }
    return null;
}

From source file:com.klinker.android.twitter.utils.api_helper.TwitterMultipleImageHelper.java

public boolean uploadPics(File[] pics, String text, Twitter twitter) {
    JSONObject jsonresponse = new JSONObject();

    final String ids_string = getMediaIds(pics, twitter);

    if (ids_string == null) {
        return false;
    }/*from ww w.  j  a v  a 2s.c om*/

    try {
        AccessToken token = twitter.getOAuthAccessToken();
        String oauth_token = token.getToken();
        String oauth_token_secret = token.getTokenSecret();

        // generate authorization header
        String get_or_post = "POST";
        String oauth_signature_method = "HMAC-SHA1";

        String uuid_string = UUID.randomUUID().toString();
        uuid_string = uuid_string.replaceAll("-", "");
        String oauth_nonce = uuid_string; // any relatively random alphanumeric string will work here

        // get the timestamp
        Calendar tempcal = Calendar.getInstance();
        long ts = tempcal.getTimeInMillis();// get current time in milliseconds
        String oauth_timestamp = (new Long(ts / 1000)).toString(); // then divide by 1000 to get seconds

        // the parameter string must be in alphabetical order, "text" parameter added at end
        String parameter_string = "oauth_consumer_key=" + AppSettings.TWITTER_CONSUMER_KEY + "&oauth_nonce="
                + oauth_nonce + "&oauth_signature_method=" + oauth_signature_method + "&oauth_timestamp="
                + oauth_timestamp + "&oauth_token=" + encode(oauth_token) + "&oauth_version=1.0";
        System.out.println("Twitter.updateStatusWithMedia(): parameter_string=" + parameter_string);

        String twitter_endpoint = "https://api.twitter.com/1.1/statuses/update.json";
        String twitter_endpoint_host = "api.twitter.com";
        String twitter_endpoint_path = "/1.1/statuses/update.json";
        String signature_base_string = get_or_post + "&" + encode(twitter_endpoint) + "&"
                + encode(parameter_string);
        String oauth_signature = computeSignature(signature_base_string,
                AppSettings.TWITTER_CONSUMER_SECRET + "&" + encode(oauth_token_secret));

        String authorization_header_string = "OAuth oauth_consumer_key=\"" + AppSettings.TWITTER_CONSUMER_KEY
                + "\",oauth_signature_method=\"HMAC-SHA1\",oauth_timestamp=\"" + oauth_timestamp
                + "\",oauth_nonce=\"" + oauth_nonce + "\",oauth_version=\"1.0\",oauth_signature=\""
                + encode(oauth_signature) + "\",oauth_token=\"" + encode(oauth_token) + "\"";

        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, "UTF-8");
        HttpProtocolParams.setUserAgent(params, "HttpCore/1.1");
        HttpProtocolParams.setUseExpectContinue(params, false);
        HttpProcessor httpproc = new ImmutableHttpProcessor(new HttpRequestInterceptor[] {
                // Required protocol interceptors
                new RequestContent(), new RequestTargetHost(),
                // Recommended protocol interceptors
                new RequestConnControl(), new RequestUserAgent(), new RequestExpectContinue() });

        HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
        HttpContext context = new BasicHttpContext(null);
        HttpHost host = new HttpHost(twitter_endpoint_host, 443);
        DefaultHttpClientConnection conn = new DefaultHttpClientConnection();

        context.setAttribute(ExecutionContext.HTTP_CONNECTION, conn);
        context.setAttribute(ExecutionContext.HTTP_TARGET_HOST, host);

        try {
            try {
                SSLContext sslcontext = SSLContext.getInstance("TLS");
                sslcontext.init(null, null, null);
                SSLSocketFactory ssf = sslcontext.getSocketFactory();
                Socket socket = ssf.createSocket();
                socket.connect(new InetSocketAddress(host.getHostName(), host.getPort()), 0);
                conn.bind(socket, params);
                BasicHttpEntityEnclosingRequest request2 = new BasicHttpEntityEnclosingRequest("POST",
                        twitter_endpoint_path);

                MultipartEntity reqEntity = new MultipartEntity();
                reqEntity.addPart("media_ids", new StringBody(ids_string));
                reqEntity.addPart("status", new StringBody(text));
                reqEntity.addPart("trim_user", new StringBody("1"));
                request2.setEntity(reqEntity);

                request2.setParams(params);
                request2.addHeader("Authorization", authorization_header_string);
                httpexecutor.preProcess(request2, httpproc, context);
                HttpResponse response2 = httpexecutor.execute(request2, conn, context);
                response2.setParams(params);
                httpexecutor.postProcess(response2, httpproc, context);
                String responseBody = EntityUtils.toString(response2.getEntity());
                System.out.println("response=" + responseBody);
                // error checking here. Otherwise, status should be updated.
                jsonresponse = new JSONObject(responseBody);
                conn.close();
            } catch (HttpException he) {
                System.out.println(he.getMessage());
                jsonresponse.put("response_status", "error");
                jsonresponse.put("message", "updateStatus HttpException message=" + he.getMessage());
            } catch (NoSuchAlgorithmException nsae) {
                System.out.println(nsae.getMessage());
                jsonresponse.put("response_status", "error");
                jsonresponse.put("message",
                        "updateStatus NoSuchAlgorithmException message=" + nsae.getMessage());
            } catch (KeyManagementException kme) {
                System.out.println(kme.getMessage());
                jsonresponse.put("response_status", "error");
                jsonresponse.put("message", "updateStatus KeyManagementException message=" + kme.getMessage());
            } finally {
                conn.close();
            }
        } catch (JSONException jsone) {
            jsone.printStackTrace();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    } catch (Exception e) {

    }
    return true;
}

From source file:org.craftercms.studio.impl.v1.service.cmis.CmisServiceImpl.java

private Session createCMISSession(DataSourceRepositoryTO config)
        throws CmisUnavailableException, CmisTimeoutException {

    if (config.isUseSsl()) {
        SSLContext sc = null;
        try {//  www.  ja  v  a  2 s.  com
            sc = getSSLContext();
            // Ignore differences between given hostname and certificate hostname
            HostnameVerifier hv = (hostname, session) -> true;
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(hv);
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            logger.error("Error initializing SSL context", e);
        }
    }

    // Create a SessionFactory and set up the SessionParameter map
    SessionFactory sessionFactory = SessionFactoryImpl.newInstance();
    Map<String, String> parameter = new HashMap<String, String>();
    parameter.put(SessionParameter.USER, config.getUsername());
    parameter.put(SessionParameter.PASSWORD, config.getPassword());

    // connection settings - we're connecting to a public cmis repo,
    // using the AtomPUB binding, but there are other options here,
    // or you can substitute your own URL
    parameter.put(SessionParameter.ATOMPUB_URL, config.getUrl());
    parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());
    parameter.put(SessionParameter.COOKIES, "true");

    // find all the repositories at this URL - there should only be one.
    List<Repository> repositories = new ArrayList<Repository>();
    repositories = sessionFactory.getRepositories(parameter);

    // create session with the first (and only) repository
    Repository repository = repositories.get(0);
    parameter.put(SessionParameter.REPOSITORY_ID, repository.getId());
    Session session = null;
    try {
        session = sessionFactory.createSession(parameter);
    } catch (CmisConnectionException e) {
        throw new CmisTimeoutException(e);
    } catch (CmisBaseException e) {
        throw new CmisUnavailableException(e);
    }

    return session;
}

From source file:net.straylightlabs.archivo.net.MindRPC.java

private SSLSocketFactory createSecureSocketFactory() {
    try {/*w w  w .ja va  2  s  . co  m*/
        SSLContext context = SSLContext.getInstance("TLS");
        KeyStore store = createKeyStore();
        KeyManagerFactory keyManagerFactory = KeyManagerFactory
                .getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(store, KEY_PASSWORD.toCharArray());
        TrustManager[] trustManagers = new TrustManager[] { new AllTrustingTrustManager() };
        context.init(keyManagerFactory.getKeyManagers(), trustManagers, null);
        return context.getSocketFactory();
    } catch (GeneralSecurityException e) {
        logger.error("Error creating custom SSLSocketFactory: ", e);
    }
    throw new AssertionError();
}

From source file:org.apache.fineract.infrastructure.sms.scheduler.SmsMessageScheduledJobServiceImpl.java

/** 
 * prevents the SSL security certificate check 
 **//*from   ww  w.j  ava  2 s .  com*/
private void trustAllSSLCertificates() {
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        public void checkClientTrusted(X509Certificate[] certs, String authType) {
        }

        public void checkServerTrusted(X509Certificate[] certs, String authType) {
        }
    } };

    try {
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, trustAllCerts, new SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());

        // Create all-trusting host name verifier
        HostnameVerifier hostnameVerifier = new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        };

        // Install the all-trusting host verifier
        HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
    }

    catch (Exception e) {
        // do nothing
    }
}

From source file:org.apache.nifi.ldap.LdapProvider.java

@Override
public final void onConfigured(final LoginIdentityProviderConfigurationContext configurationContext)
        throws ProviderCreationException {
    final String rawExpiration = configurationContext.getProperty("Authentication Expiration");
    if (StringUtils.isBlank(rawExpiration)) {
        throw new ProviderCreationException("The Authentication Expiration must be specified.");
    }/*  ww w. j  av a 2  s . com*/

    try {
        expiration = FormatUtils.getTimeDuration(rawExpiration, TimeUnit.MILLISECONDS);
    } catch (final IllegalArgumentException iae) {
        throw new ProviderCreationException(
                String.format("The Expiration Duration '%s' is not a valid time duration", rawExpiration));
    }

    final LdapContextSource context = new LdapContextSource();

    final Map<String, Object> baseEnvironment = new HashMap<>();

    // connect/read time out
    setTimeout(configurationContext, baseEnvironment, "Connect Timeout", "com.sun.jndi.ldap.connect.timeout");
    setTimeout(configurationContext, baseEnvironment, "Read Timeout", "com.sun.jndi.ldap.read.timeout");

    // authentication strategy
    final String rawAuthenticationStrategy = configurationContext.getProperty("Authentication Strategy");
    final LdapAuthenticationStrategy authenticationStrategy;
    try {
        authenticationStrategy = LdapAuthenticationStrategy.valueOf(rawAuthenticationStrategy);
    } catch (final IllegalArgumentException iae) {
        throw new ProviderCreationException(String.format(
                "Unrecognized authentication strategy '%s'. Possible values are [%s]",
                rawAuthenticationStrategy, StringUtils.join(LdapAuthenticationStrategy.values(), ", ")));
    }

    switch (authenticationStrategy) {
    case ANONYMOUS:
        context.setAnonymousReadOnly(true);
        break;
    default:
        final String userDn = configurationContext.getProperty("Manager DN");
        final String password = configurationContext.getProperty("Manager Password");

        context.setUserDn(userDn);
        context.setPassword(password);

        switch (authenticationStrategy) {
        case SIMPLE:
            context.setAuthenticationStrategy(new SimpleDirContextAuthenticationStrategy());
            break;
        case LDAPS:
            context.setAuthenticationStrategy(new SimpleDirContextAuthenticationStrategy());

            // indicate a secure connection
            baseEnvironment.put(Context.SECURITY_PROTOCOL, "ssl");

            // get the configured ssl context
            final SSLContext ldapsSslContext = getConfiguredSslContext(configurationContext);
            if (ldapsSslContext != null) {
                // initialize the ldaps socket factory prior to use
                LdapsSocketFactory.initialize(ldapsSslContext.getSocketFactory());
                baseEnvironment.put("java.naming.ldap.factory.socket", LdapsSocketFactory.class.getName());
            }
            break;
        case START_TLS:
            final AbstractTlsDirContextAuthenticationStrategy tlsAuthenticationStrategy = new DefaultTlsDirContextAuthenticationStrategy();

            // shutdown gracefully
            final String rawShutdownGracefully = configurationContext.getProperty("TLS - Shutdown Gracefully");
            if (StringUtils.isNotBlank(rawShutdownGracefully)) {
                final boolean shutdownGracefully = Boolean.TRUE.toString()
                        .equalsIgnoreCase(rawShutdownGracefully);
                tlsAuthenticationStrategy.setShutdownTlsGracefully(shutdownGracefully);
            }

            // get the configured ssl context
            final SSLContext startTlsSslContext = getConfiguredSslContext(configurationContext);
            if (startTlsSslContext != null) {
                tlsAuthenticationStrategy.setSslSocketFactory(startTlsSslContext.getSocketFactory());
            }

            // set the authentication strategy
            context.setAuthenticationStrategy(tlsAuthenticationStrategy);
            break;
        }
        break;
    }

    // referrals
    final String rawReferralStrategy = configurationContext.getProperty("Referral Strategy");

    final ReferralStrategy referralStrategy;
    try {
        referralStrategy = ReferralStrategy.valueOf(rawReferralStrategy);
    } catch (final IllegalArgumentException iae) {
        throw new ProviderCreationException(
                String.format("Unrecognized referral strategy '%s'. Possible values are [%s]",
                        rawReferralStrategy, StringUtils.join(ReferralStrategy.values(), ", ")));
    }

    // using the value as this needs to be the lowercase version while the value is configured with the enum constant
    context.setReferral(referralStrategy.getValue());

    // url
    final String urls = configurationContext.getProperty("Url");

    if (StringUtils.isBlank(urls)) {
        throw new ProviderCreationException("LDAP identity provider 'Url' must be specified.");
    }

    // connection
    context.setUrls(StringUtils.split(urls));

    // search criteria
    final String userSearchBase = configurationContext.getProperty("User Search Base");
    final String userSearchFilter = configurationContext.getProperty("User Search Filter");

    if (StringUtils.isBlank(userSearchBase) || StringUtils.isBlank(userSearchFilter)) {
        throw new ProviderCreationException(
                "LDAP identity provider 'User Search Base' and 'User Search Filter' must be specified.");
    }

    final LdapUserSearch userSearch = new FilterBasedLdapUserSearch(userSearchBase, userSearchFilter, context);

    // bind
    final BindAuthenticator authenticator = new BindAuthenticator(context);
    authenticator.setUserSearch(userSearch);

    // identity strategy
    final String rawIdentityStrategy = configurationContext.getProperty("Identity Strategy");

    if (StringUtils.isBlank(rawIdentityStrategy)) {
        logger.info(String.format("Identity Strategy is not configured, defaulting strategy to %s.",
                IdentityStrategy.USE_DN));

        // if this value is not configured, default to use dn which was the previous implementation
        identityStrategy = IdentityStrategy.USE_DN;
    } else {
        try {
            // attempt to get the configured identity strategy
            identityStrategy = IdentityStrategy.valueOf(rawIdentityStrategy);
        } catch (final IllegalArgumentException iae) {
            throw new ProviderCreationException(
                    String.format("Unrecognized identity strategy '%s'. Possible values are [%s]",
                            rawIdentityStrategy, StringUtils.join(IdentityStrategy.values(), ", ")));
        }
    }

    // set the base environment is necessary
    if (!baseEnvironment.isEmpty()) {
        context.setBaseEnvironmentProperties(baseEnvironment);
    }

    try {
        // handling initializing beans
        context.afterPropertiesSet();
        authenticator.afterPropertiesSet();
    } catch (final Exception e) {
        throw new ProviderCreationException(e.getMessage(), e);
    }

    // create the underlying provider
    provider = new LdapAuthenticationProvider(authenticator);
}

From source file:com.irccloud.android.HTTPFetcher.java

private SSLSocketFactory getSSLSocketFactory() throws NoSuchAlgorithmException, KeyManagementException {
    SSLContext context = SSLContext.getInstance("TLS");

    TrustManager[] trustManagers = null;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        trustManagers = new TrustManager[1];
        trustManagers[0] = TrustKit.getInstance().getTrustManager(mURI.getHost());
    }/*from  w w  w.  j ava 2s.c o m*/

    context.init(null, trustManagers, null);
    return context.getSocketFactory();
}

From source file:org.apache.nifi.registry.security.ldap.LdapIdentityProvider.java

@Override
public final void onConfigured(final IdentityProviderConfigurationContext configurationContext)
        throws SecurityProviderCreationException {
    final String rawExpiration = configurationContext.getProperty("Authentication Expiration");
    if (StringUtils.isBlank(rawExpiration)) {
        throw new SecurityProviderCreationException("The Authentication Expiration must be specified.");
    }//from www  .j  a  va  2 s  .  c  o m

    try {
        expiration = FormatUtils.getTimeDuration(rawExpiration, TimeUnit.MILLISECONDS);
    } catch (final IllegalArgumentException iae) {
        throw new SecurityProviderCreationException(
                String.format("The Expiration Duration '%s' is not a valid time duration", rawExpiration));
    }

    final LdapContextSource context = new LdapContextSource();

    final Map<String, Object> baseEnvironment = new HashMap<>();

    // connect/read time out
    setTimeout(configurationContext, baseEnvironment, "Connect Timeout", "com.sun.jndi.ldap.connect.timeout");
    setTimeout(configurationContext, baseEnvironment, "Read Timeout", "com.sun.jndi.ldap.read.timeout");

    // authentication strategy
    final String rawAuthenticationStrategy = configurationContext.getProperty("Authentication Strategy");
    final LdapAuthenticationStrategy authenticationStrategy;
    try {
        authenticationStrategy = LdapAuthenticationStrategy.valueOf(rawAuthenticationStrategy);
    } catch (final IllegalArgumentException iae) {
        throw new SecurityProviderCreationException(String.format(
                "Unrecognized authentication strategy '%s'. Possible values are [%s]",
                rawAuthenticationStrategy, StringUtils.join(LdapAuthenticationStrategy.values(), ", ")));
    }

    switch (authenticationStrategy) {
    case ANONYMOUS:
        context.setAnonymousReadOnly(true);
        break;
    default:
        final String userDn = configurationContext.getProperty("Manager DN");
        final String password = configurationContext.getProperty("Manager Password");

        context.setUserDn(userDn);
        context.setPassword(password);

        switch (authenticationStrategy) {
        case SIMPLE:
            context.setAuthenticationStrategy(new SimpleDirContextAuthenticationStrategy());
            break;
        case LDAPS:
            context.setAuthenticationStrategy(new SimpleDirContextAuthenticationStrategy());

            // indicate a secure connection
            baseEnvironment.put(Context.SECURITY_PROTOCOL, "ssl");

            // get the configured ssl context
            final SSLContext ldapsSslContext = getConfiguredSslContext(configurationContext);
            if (ldapsSslContext != null) {
                // initialize the ldaps socket factory prior to use
                LdapsSocketFactory.initialize(ldapsSslContext.getSocketFactory());
                baseEnvironment.put("java.naming.ldap.factory.socket", LdapsSocketFactory.class.getName());
            }
            break;
        case START_TLS:
            final AbstractTlsDirContextAuthenticationStrategy tlsAuthenticationStrategy = new DefaultTlsDirContextAuthenticationStrategy();

            // shutdown gracefully
            final String rawShutdownGracefully = configurationContext.getProperty("TLS - Shutdown Gracefully");
            if (StringUtils.isNotBlank(rawShutdownGracefully)) {
                final boolean shutdownGracefully = Boolean.TRUE.toString()
                        .equalsIgnoreCase(rawShutdownGracefully);
                tlsAuthenticationStrategy.setShutdownTlsGracefully(shutdownGracefully);
            }

            // get the configured ssl context
            final SSLContext startTlsSslContext = getConfiguredSslContext(configurationContext);
            if (startTlsSslContext != null) {
                tlsAuthenticationStrategy.setSslSocketFactory(startTlsSslContext.getSocketFactory());
            }

            // set the authentication strategy
            context.setAuthenticationStrategy(tlsAuthenticationStrategy);
            break;
        }
        break;
    }

    // referrals
    final String rawReferralStrategy = configurationContext.getProperty("Referral Strategy");

    final ReferralStrategy referralStrategy;
    try {
        referralStrategy = ReferralStrategy.valueOf(rawReferralStrategy);
    } catch (final IllegalArgumentException iae) {
        throw new SecurityProviderCreationException(
                String.format("Unrecognized referral strategy '%s'. Possible values are [%s]",
                        rawReferralStrategy, StringUtils.join(ReferralStrategy.values(), ", ")));
    }

    // using the value as this needs to be the lowercase version while the value is configured with the enum constant
    context.setReferral(referralStrategy.getValue());

    // url
    final String urls = configurationContext.getProperty("Url");

    if (StringUtils.isBlank(urls)) {
        throw new SecurityProviderCreationException("LDAP identity provider 'Url' must be specified.");
    }

    // connection
    context.setUrls(StringUtils.split(urls));

    // search criteria
    final String userSearchBase = configurationContext.getProperty("User Search Base");
    final String userSearchFilter = configurationContext.getProperty("User Search Filter");

    if (StringUtils.isBlank(userSearchBase) || StringUtils.isBlank(userSearchFilter)) {
        throw new SecurityProviderCreationException(
                "LDAP identity provider 'User Search Base' and 'User Search Filter' must be specified.");
    }

    final LdapUserSearch userSearch = new FilterBasedLdapUserSearch(userSearchBase, userSearchFilter, context);

    // bind
    final BindAuthenticator authenticator = new BindAuthenticator(context);
    authenticator.setUserSearch(userSearch);

    // identity strategy
    final String rawIdentityStrategy = configurationContext.getProperty("Identity Strategy");

    if (StringUtils.isBlank(rawIdentityStrategy)) {
        logger.info(String.format("Identity Strategy is not configured, defaulting strategy to %s.",
                IdentityStrategy.USE_DN));

        // if this value is not configured, default to use dn which was the previous implementation
        identityStrategy = IdentityStrategy.USE_DN;
    } else {
        try {
            // attempt to get the configured identity strategy
            identityStrategy = IdentityStrategy.valueOf(rawIdentityStrategy);
        } catch (final IllegalArgumentException iae) {
            throw new SecurityProviderCreationException(
                    String.format("Unrecognized identity strategy '%s'. Possible values are [%s]",
                            rawIdentityStrategy, StringUtils.join(IdentityStrategy.values(), ", ")));
        }
    }

    // set the base environment is necessary
    if (!baseEnvironment.isEmpty()) {
        context.setBaseEnvironmentProperties(baseEnvironment);
    }

    try {
        // handling initializing beans
        context.afterPropertiesSet();
        authenticator.afterPropertiesSet();
    } catch (final Exception e) {
        throw new SecurityProviderCreationException(e.getMessage(), e);
    }

    // create the underlying provider
    ldapAuthenticationProvider = new LdapAuthenticationProvider(authenticator);
}