org.apache.activemq.broker.SslContext Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of activemq-client Show documentation
The ActiveMQ Client implementation
There is a newer version: 6.1.4
/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.activemq.broker;

import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;

/**
 * A holder of SSL configuration.
 */
public class SslContext {
    
    protected String protocol = "TLS";
    protected String provider = null;
    protected List keyManagers = new ArrayList();
    protected List trustManagers = new ArrayList();
    protected SecureRandom secureRandom;
    private volatile boolean initialized;
    private SSLContext sslContext;
    
    private static final ThreadLocal current = new ThreadLocal();
    
    public SslContext() {
    }
    
    public SslContext(KeyManager[] km, TrustManager[] tm, SecureRandom random) {
        if( km!=null ) {
            setKeyManagers(Arrays.asList(km));
        }
        if( tm!=null ) {
            setTrustManagers(Arrays.asList(tm));
        }
        setSecureRandom(random);        
    }
    
    static public void setCurrentSslContext(SslContext bs) {
        current.set(bs);
    }
    static public SslContext getCurrentSslContext() {
        return current.get();
    }
    
    public KeyManager[] getKeyManagersAsArray() {
        KeyManager rc[] = new KeyManager[keyManagers.size()];
        return keyManagers.toArray(rc);
    }
    public TrustManager[] getTrustManagersAsArray() {
        TrustManager rc[] = new TrustManager[trustManagers.size()];
        return trustManagers.toArray(rc);
    }
    
    public void addKeyManager(KeyManager km) {
        keyManagers.add(km);
    }
    public boolean removeKeyManager(KeyManager km) {
        return keyManagers.remove(km);
    }
    public void addTrustManager(TrustManager tm) {
        trustManagers.add(tm);
    }
    public boolean removeTrustManager(TrustManager tm) {
        return trustManagers.remove(tm);
    }
    
    public List getKeyManagers() {
        return keyManagers;
    }
    public void setKeyManagers(List keyManagers) {
        this.keyManagers = keyManagers;
    }
    public List getTrustManagers() {
        return trustManagers;
    }
    public void setTrustManagers(List trustManagers) {
        this.trustManagers = trustManagers;
    }
    public SecureRandom getSecureRandom() {
        return secureRandom;
    }
    public void setSecureRandom(SecureRandom secureRandom) {
        this.secureRandom = secureRandom;
    }
        
    public String getProtocol() {
        return protocol;
    }
    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }
    public String getProvider() {
        return provider;
    }
    public void setProvider(String provider) {
        this.provider = provider;
    }

    public SSLContext getSSLContext() throws NoSuchProviderException, NoSuchAlgorithmException, KeyManagementException {
        if (!initialized) {
            synchronized (this) {
                if (!initialized) {
                    if (provider == null) {
                        sslContext = SSLContext.getInstance(protocol);
                    } else {
                        sslContext = SSLContext.getInstance(protocol, provider);
                    }
                    sslContext.init(getKeyManagersAsArray(), getTrustManagersAsArray(), getSecureRandom());
                    initialized = true;
                }
            }
        }
        return sslContext;
    }
    public synchronized void setSSLContext(SSLContext sslContext) {
        this.sslContext = sslContext;
        initialized = true;
    }
    
    
}