Examples of io.netty.handler.ssl.SslHandler

io.netty.handler.ssl.SslHandler
kipedia.org/wiki/Transport_Layer_Security">SSL · TLS and StartTLS support to a {@link Channel}. Please refer to the "SecureChat" example in the distribution or the web site for the detailed usage.
Beginning the handshake

You must make sure not to write a message while the {@linkplain #handshake() handshake} is in progress unless you arerenegotiating. You will be notified by the {@link ChannelFuture} which isreturned by the {@link #handshake()} method when the handshakeprocess succeeds or fails.
Handshake

If {@link #isIssueHandshake()} is {@code false}(default) you will need to take care of calling {@link #handshake()} by your own. In most situations were {@link SslHandler} is used in 'client mode'you want to issue a handshake once the connection was established. if {@link #setIssueHandshake(boolean)} is set to true you don't need to worry about this as the {@link SslHandler} will take care of it.

Renegotiation

If {@link #isEnableRenegotiation() enableRenegotiation} is {@code true}(default) and the initial handshake has been done successfully, you can call {@link #handshake()} to trigger the renegotiation.
If {@link #isEnableRenegotiation() enableRenegotiation} is {@code false}, an attempt to trigger renegotiation will result in the connection closure.
Please note that TLS renegotiation had a security issue before. If your runtime environment did not fix it, please make sure to disable TLS renegotiation by calling {@link #setEnableRenegotiation(boolean)} with{@code false}. For more information, please refer to the following documents:
Closing the session

To close the SSL session, the {@link #close()} method should becalled to send the {@code close_notify} message to the remote peer. Oneexception is when you close the {@link Channel} - {@link SslHandler}intercepts the close request and send the {@code close_notify} messagebefore the channel closure automatically. Once the SSL session is closed, it is not reusable, and consequently you should create a new {@link SslHandler} with a new {@link SSLEngine} as explained in thefollowing section.
Restarting the session

To restart the SSL session, you must remove the existing closed {@link SslHandler} from the {@link ChannelPipeline}, insert a new {@link SslHandler} with a new {@link SSLEngine} into the pipeline,and start the handshake process as described in the first section.
Implementing StartTLS

StartTLS is the communication pattern that secures the wire in the middle of the plaintext connection. Please note that it is different from SSL · TLS, that secures the wire from the beginning of the connection. Typically, StartTLS is composed of three steps:
1. Client sends a StartTLS request to server.
2. Server sends a StartTLS response to client.
3. Client begins SSL handshake.
If you implement a server, you need to:
1. create a new {@link SslHandler} instance with {@code startTls} flag setto {@code true},
2. insert the {@link SslHandler} to the {@link ChannelPipeline}, and
3. write a StartTLS response.
Please note that you must insert {@link SslHandler} before sendingthe StartTLS response. Otherwise the client can send begin SSL handshake before {@link SslHandler} is inserted to the {@link ChannelPipeline}, causing data corruption.
The client-side implementation is much simpler.
1. Write a StartTLS request,
2. wait for the StartTLS response,
3. create a new {@link SslHandler} instance with {@code startTls} flag setto {@code false},
4. insert the {@link SslHandler} to the {@link ChannelPipeline}, and
5. Initiate SSL handshake by calling {@link SslHandler#handshake()}.
@apiviz.landmark @apiviz.uses io.netty.handler.ssl.SslBufferPool


         NettyServerConnection nc = new NettyServerConnection(configuration, ctx.channel(), connectionListener, !httpEnabled && batchDelay > 0, directDeliver);


         connectionListener.connectionCreated(NettyAcceptor.this, nc, protocol);


         SslHandler sslHandler = ctx.pipeline().get(SslHandler.class);
         if (sslHandler != null)
         {
            sslHandler.handshakeFuture().addListener(new GenericFutureListener<io.netty.util.concurrent.Future<Channel>>()
            {
               public void operationComplete(final io.netty.util.concurrent.Future<Channel> future) throws Exception
               {
                  if (future.isSuccess())
                  {

View Full Code Here

    }


    private boolean initPipeline(ChannelHandlerContext ctx) {
        // Get the SslHandler from the ChannelPipeline so we can obtain the
        // SslEngine from it.
        SslHandler handler = ctx.pipeline().get(SslHandler.class);
        if (handler == null) {
            // HTTP2 is negotiated through SSL.
            throw new IllegalStateException("SslHandler is needed for HTTP2");
        }


        SelectedProtocol protocol = getProtocol(handler.engine());
        switch (protocol) {
            case UNKNOWN:
                // Not done with choosing the protocol, so just return here for now,
                return false;
            case HTTP_2:

View Full Code Here

        }


        if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(false);
            pipeline.addLast(SSL_HANDLER, new SslHandler(engine));
        }


        pipeline.addLast(HTTP_REQUEST_DECODER, new HttpRequestDecoder());
        pipeline.addLast(HTTP_AGGREGATOR, new HttpObjectAggregator(configuration.getMaxHttpContentLength()));
        pipeline.addLast(HTTP_ENCODER, new HttpResponseEncoder());

View Full Code Here

      if (closed)
      {
         return;
      }


      final SslHandler sslHandler = (SslHandler)channel.pipeline().get("ssl");
      EventLoop eventLoop = channel.eventLoop();
      boolean inEventLoop = eventLoop.inEventLoop();
      //if we are in an event loop we need to close the channel after the writes have finished
      if(!inEventLoop)
      {

View Full Code Here

                  else
                  {
                     engine.setEnabledProtocols(originalProtocols);
                  }


                  SslHandler handler = new SslHandler(engine);


                  pipeline.addLast(handler);
              }


              if (httpEnabled) {

View Full Code Here

      future.awaitUninterruptibly();


       if (future.isSuccess())
      {
         final Channel ch = future.channel();
         SslHandler sslHandler = ch.pipeline().get(SslHandler.class);
         if (sslHandler != null)
         {
            Future<Channel> handshakeFuture = sslHandler.handshakeFuture();
            if (handshakeFuture.awaitUninterruptibly(30000))
            {
               if (handshakeFuture.isSuccess())
               {
                  ch.pipeline().get(HornetQChannelHandler.class).active = true;

View Full Code Here

    }


    private boolean initPipeline(ChannelHandlerContext ctx) {
        // Get the SslHandler from the ChannelPipeline so we can obtain the
        // SslEngine from it.
        SslHandler handler = ctx.pipeline().get(SslHandler.class);
        if (handler == null) {
            // SslHandler is needed by SPDY by design.
            throw new IllegalStateException("SslHandler is needed for SPDY");
        }


        SelectedProtocol protocol = getProtocol(handler.engine());
        switch (protocol) {
        case UNKNOWN:
            // Not done with choosing the protocol, so just return here for now,
            return false;
        case SPDY_3_1:

View Full Code Here


        SSLEngine engine =
            SecureChatSslContextFactory.getServerContext().createSSLEngine();
        engine.setUseClientMode(false);


        pipeline.addLast("ssl", new SslHandler(engine));


        // On top of the SSL handler, add the text line codec.
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                8192, Delimiters.lineDelimiter()));
        pipeline.addLast("decoder", new StringDecoder());

View Full Code Here

    @Override
    public void channelConnected(
            ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
        // Get the SslHandler from the pipeline
        // which were added in SecureChatPipelineFactory.
        SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class);


        // Begin handshake.
        sslHandler.handshake();
    }

View Full Code Here

    public void channelConnected(
            ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {


        // Get the SslHandler in the current pipeline.
        // We added it in SecureChatPipelineFactory.
        final SslHandler sslHandler = ctx.getPipeline().get(SslHandler.class);


        // Get notified when SSL handshake is done.
        ChannelFuture handshakeFuture = sslHandler.handshake();
        handshakeFuture.addListener(new Greeter(sslHandler));
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of io.netty.handler.ssl.SslHandler

com.corundumstudio.socketio.SocketIOChannelInitializer

com.relayrides.pushy.apns.ApnsConnection

com.relayrides.pushy.apns.FeedbackServiceConnection

io.netty.buffer.ByteBuf

io.netty.buffer.ByteBufAllocator

io.netty.buffer.ChannelBuffer

io.netty.channel.Channel

io.netty.channel.ChannelFuture

io.netty.channel.ChannelFutureListener

io.netty.channel.ChannelHandlerContext

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of io.netty.handler.ssl.SslHandler

Beginning the handshake

Handshake

Renegotiation

Closing the session

Restarting the session

Implementing StartTLS

Related Classes of io.netty.handler.ssl.SslHandler