Java SSLFactory类代码示例

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public Socket createConnection(InetAddress peer) throws IOException
{
    // Connect to secure port for all peers if ServerEncryptionOptions is configured other than 'none'
    // When 'all', 'dc' and 'rack', server nodes always have SSL port open, and since thin client like sstableloader
    // does not know which node is in which dc/rack, connecting to SSL port is always the option.
    if (encryptionOptions != null && encryptionOptions.internode_encryption != EncryptionOptions.ServerEncryptionOptions.InternodeEncryption.none)
    {
        if (outboundBindAny)
            return SSLFactory.getSocket(encryptionOptions, peer, secureStoragePort);
        else
            return SSLFactory.getSocket(encryptionOptions, peer, secureStoragePort, FBUtilities.getLocalAddress(), 0);
    }
    else
    {
        Socket socket = SocketChannel.open(new InetSocketAddress(peer, storagePort)).socket();
        if (outboundBindAny && !socket.isBound())
            socket.bind(new InetSocketAddress(FBUtilities.getLocalAddress(), 0));
        return socket;
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public static Socket newSocket(InetAddress endpoint) throws IOException
{
    // zero means 'bind on any available port.'
    if (isEncryptedChannel(endpoint))
    {
        if (Config.getOutboundBindAny())
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endpoint, DatabaseDescriptor.getSSLStoragePort());
        else
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endpoint, DatabaseDescriptor.getSSLStoragePort(), FBUtilities.getLocalAddress(), 0);
    }
    else
    {
        Socket socket = SocketChannel.open(new InetSocketAddress(endpoint, DatabaseDescriptor.getStoragePort())).socket();
        if (Config.getOutboundBindAny() && !socket.isBound())
            socket.bind(new InetSocketAddress(FBUtilities.getLocalAddress(), 0));
        return socket;
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
private static SSLOptions buildSSLOptions(EncryptionOptions.ClientEncryptionOptions clientEncryptionOptions)
{

    if (!clientEncryptionOptions.enabled)
        return null;

    SSLContext sslContext;
    try
    {
        sslContext = SSLFactory.createSSLContext(clientEncryptionOptions, true);
    }
    catch (IOException e)
    {
        throw new RuntimeException("Could not create SSL Context.", e);
    }

    return JdkSSLOptions.builder()
                        .withSSLContext(sslContext)
                        .withCipherSuites(clientEncryptionOptions.cipher_suites)
                        .build();
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
@SuppressWarnings("resource")
public static Socket newSocket(InetAddress endpoint) throws IOException
{
    // zero means 'bind on any available port.'
    if (isEncryptedChannel(endpoint))
    {
        if (Config.getOutboundBindAny())
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endpoint, DatabaseDescriptor.getSSLStoragePort());
        else
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endpoint, DatabaseDescriptor.getSSLStoragePort(), FBUtilities.getLocalAddress(), 0);
    }
    else
    {
        SocketChannel channel = SocketChannel.open();
        if (!Config.getOutboundBindAny())
            channel.bind(new InetSocketAddress(FBUtilities.getLocalAddress(), 0));
        channel.connect(new InetSocketAddress(endpoint, DatabaseDescriptor.getStoragePort()));
        return channel.socket();
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public Socket newSocket() throws IOException
{
    // zero means 'bind on any available port.'
    if (isEncryptedChannel())
    {
        if (Config.getOutboundBindAny())
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endPoint(), DatabaseDescriptor.getSSLStoragePort());
        else
            return SSLFactory.getSocket(DatabaseDescriptor.getServerEncryptionOptions(), endPoint(), DatabaseDescriptor.getSSLStoragePort(), FBUtilities.getLocalAddress(), 0);
    }
    else
    {
        Socket socket = SocketChannel.open(new InetSocketAddress(endPoint(), DatabaseDescriptor.getStoragePort())).socket();
        if (Config.getOutboundBindAny() && !socket.isBound())
            socket.bind(new InetSocketAddress(FBUtilities.getLocalAddress(), 0));
        return socket;
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public SecureInitializer(Server server, EncryptionOptions encryptionOptions)
{
    super(server);
    this.encryptionOptions = encryptionOptions;
    try
    {
        this.sslContext = SSLFactory.createSSLContext(encryptionOptions, encryptionOptions.require_client_auth);
    }
    catch (IOException e)
    {
        throw new RuntimeException("Failed to setup secure pipeline", e);
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
protected void initChannel(Channel channel) throws Exception
{
    SSLEngine sslEngine = sslContext.createSSLEngine();
    sslEngine.setUseClientMode(false);
    sslEngine.setEnabledCipherSuites(encryptionOptions.cipher_suites);
    sslEngine.setNeedClientAuth(encryptionOptions.require_client_auth);
    sslEngine.setEnabledProtocols(SSLFactory.ACCEPTED_PROTOCOLS);
    SslHandler sslHandler = new SslHandler(sslEngine);
    super.initChannel(channel);
    channel.pipeline().addFirst("ssl", sslHandler);
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
protected void initChannel(Channel channel) throws Exception
{
    super.initChannel(channel);
    SSLEngine sslEngine = sslContext.createSSLEngine();
    sslEngine.setUseClientMode(true);
    sslEngine.setEnabledCipherSuites(encryptionOptions.cipher_suites);
    sslEngine.setEnabledProtocols(SSLFactory.ACCEPTED_PROTOCOLS);
    channel.pipeline().addFirst("ssl", new SslHandler(sslEngine));
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public SecurePipelineFactory(Server server, EncryptionOptions encryptionOptions)
{
    super(server);
    this.encryptionOptions = encryptionOptions;
    try
    {
        this.sslContext = SSLFactory.createSSLContext(encryptionOptions, false);
    }
    catch (IOException e)
    {
        throw new RuntimeException("Failed to setup secure pipeline", e);
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
protected AbstractSecureIntializer(Server server, EncryptionOptions encryptionOptions)
{
    super(server);
    this.encryptionOptions = encryptionOptions;
    try
    {
        this.sslContext = SSLFactory.createSSLContext(encryptionOptions, encryptionOptions.require_client_auth);
    }
    catch (IOException e)
    {
        throw new RuntimeException("Failed to setup secure pipeline", e);
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
protected final SslHandler createSslHandler() {
    SSLEngine sslEngine = sslContext.createSSLEngine();
    sslEngine.setUseClientMode(false);
    String[] suites = SSLFactory.filterCipherSuites(sslEngine.getSupportedCipherSuites(), encryptionOptions.cipher_suites);
    sslEngine.setEnabledCipherSuites(suites);
    sslEngine.setNeedClientAuth(encryptionOptions.require_client_auth);
    sslEngine.setEnabledProtocols(SSLFactory.ACCEPTED_PROTOCOLS);
    return new SslHandler(sslEngine);
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
protected void initChannel(Channel channel) throws Exception
{
    super.initChannel(channel);
    SSLEngine sslEngine = sslContext.createSSLEngine();
    sslEngine.setUseClientMode(true);
    String[] suites = SSLFactory.filterCipherSuites(sslEngine.getSupportedCipherSuites(), encryptionOptions.cipher_suites);
    sslEngine.setEnabledCipherSuites(suites);
    sslEngine.setEnabledProtocols(SSLFactory.ACCEPTED_PROTOCOLS);
    channel.pipeline().addFirst("ssl", new SslHandler(sslEngine));
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public SecurePipelineFactory(Server server, EncryptionOptions encryptionOptions)
{
    super(server);
    this.encryptionOptions = encryptionOptions;
    try
    {
        this.sslContext = SSLFactory.createSSLContext(encryptionOptions, encryptionOptions.require_client_auth);
    }
    catch (IOException e)
    {
        throw new RuntimeException("Failed to setup secure pipeline", e);
    }
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
private ServerSocket getServerSocket(InetAddress localEp) throws IOException, ConfigurationException
{
    final ServerSocket ss;
    if (DatabaseDescriptor.getEncryptionOptions() != null && DatabaseDescriptor.getEncryptionOptions().internode_encryption == EncryptionOptions.InternodeEncryption.all)
    {
        ss = SSLFactory.getServerSocket(DatabaseDescriptor.getEncryptionOptions(), localEp, DatabaseDescriptor.getStoragePort());
        // setReuseAddress happens in the factory.
        logger_.info("Starting Encrypted Messaging Service on port {}", DatabaseDescriptor.getStoragePort());
    }
    else
    {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        ss = serverChannel.socket();
        ss.setReuseAddress(true);
        InetSocketAddress address = new InetSocketAddress(localEp, DatabaseDescriptor.getStoragePort());
        try
        {
            ss.bind(address);
        }
        catch (BindException e)
        {
            if (e.getMessage().contains("in use"))
                throw new ConfigurationException(address + " is in use by another process.  Change listen_address:storage_port in cassandra.yaml to values that do not conflict with other services");
            else if (e.getMessage().contains("Cannot assign requested address"))
                throw new ConfigurationException("Unable to bind to address " + address + ". Set listen_address in cassandra.yaml to an interface you can bind to, e.g., your private IP address on EC2");
            else
                throw e;
        }
        logger_.info("Starting Messaging Service on {}", address);
    }
    return ss;
}
 

import org.apache.cassandra.security.SSLFactory; //导入依赖的package包/类
public SecureInitializer() throws IOException
{
    this.sslContext = SSLFactory.createSSLContext(encryptionOptions, true);
}