ruby-tls 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7767f8988f4ed0509937bd7a62a58797c0517a8
-  data.tar.gz: f121662222885ede7f33dee6716358960936975b
+  metadata.gz: acce3678093f001d9085b46b4c163c4036a6dee0
+  data.tar.gz: 1f7ab340aa973063db130f597334ccf7505d45a8
 SHA512:
-  metadata.gz: d497a9ec2805b26b7620b1347ccb6912e553e68f740b51db63d97dbe9033e7cc717e70440677de920046ac2cb5c14a3cb75ec4155f39ca19507b747a0b66b007
-  data.tar.gz: 6a4ca688ff5609abde4f43f84befbd7f9e5c2fcf4329ff34e59a937a91b8b3d91e4a834f7ae4c71524d44072438c44cc4ec60274c0befef69b2343627edf2750
+  metadata.gz: edbee0e101783904e9fdadf6fdc1fccfc7785b3b69a798223ba36656ed71af5e475407a04a72a1c195688b3f6a6909a3e1ef20fd931db46309a4622e77fc56cb
+  data.tar.gz: 43dd6bb0b6a323bb282cdbdef4a2b81623cf01dfdc88ea28cb2df1cb66fc27d3caf8b8cf8c4659f51e8b574f60968b2a27fd03cd672472df853817864b94f33e

data/README.md

@@ -34,6 +34,8 @@ class transport
       private_key: '/file/path.pem',
       cert_chain: '/file/path.crt',
       ciphers: 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-RC4-SHA:ECDHE-RSA-AES128-SHA:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH:!CAMELLIA:@STRENGTH' # (default)
+      # protocols: ["h2", "http/1.1"], # Can be used where OpenSSL >= 1.0.2 (Application Level Protocol negotiation)
+      # fallback: "http/1.1" # Optional fallback to a default protocol when either client or server doesn't support ALPN
     }
     @ssl_layer = RubyTls::SSL::Box.new(is_server, callback_obj, options)
   end
@@ -51,7 +53,7 @@ class transport
     # @tcp.send data
   end
 
-  def handshake_cb
+  def handshake_cb(protocol)
     puts "initial handshake has completed"
   end
 

data/lib/ruby-tls/ssl.rb

@@ -147,7 +147,30 @@ module RubyTls
         attach_function :SSL_CTX_set_cipher_list, [:ssl_ctx, :string], :int
         attach_function :SSL_CTX_set_session_id_context, [:ssl_ctx, :string, :buffer_length], :int
 
-        # TODO:: SSL_CTX_set_alpn_protos
+        # OpenSSL before 1.0.2 do not have these methods
+        begin
+            attach_function :SSL_CTX_set_alpn_protos, [:ssl_ctx, :string, :uint], :int
+
+            SSL_TLSEXT_ERR_OK = 0
+            SSL_TLSEXT_ERR_ALERT_WARNING = 1
+            SSL_TLSEXT_ERR_ALERT_FATAL = 2
+            SSL_TLSEXT_ERR_NOACK = 3
+
+            OPENSSL_NPN_UNSUPPORTED = 0
+            OPENSSL_NPN_NEGOTIATED = 1
+            OPENSSL_NPN_NO_OVERLAP = 2
+
+            attach_function :SSL_select_next_proto, [:pointer, :pointer, :string, :uint, :string, :uint], :int
+
+                                       # array of str, unit8 out,uint8 in,        *arg
+            callback :alpn_select_cb, [:ssl, :pointer, :pointer, :string, :uint, :pointer], :int
+            attach_function :SSL_CTX_set_alpn_select_cb, [:ssl_ctx, :alpn_select_cb, :pointer], :void
+
+            attach_function :SSL_get0_alpn_selected, [:ssl, :pointer, :pointer], :void
+            ALPN_SUPPORTED = true
+        rescue FFI::NotFoundError
+            ALPN_SUPPORTED = false
+        end
 
 
         # Deconstructor
@@ -201,19 +224,23 @@ keystr
             8
         end
 
-        CRYPTO_LOCK = 0x1
-        LockingCB = FFI::Function.new(:void, [:int, :int, :string, :int]) do |mode, type, file, line|
-            if (mode & CRYPTO_LOCK) != 0
-                SSL_LOCKS[type].lock
-            else
-                # Unlock a lock
-                SSL_LOCKS[type].unlock
-            end
-        end
+        # Locking isn't provided as long as all writes are done on the same thread.
+        # This is my main use case. Happy to enable it if someone requires it and can
+        # get it to work on MRI Ruby (Currently only works on JRuby and Rubinius)
+        # as MRI callbacks occur on a thread pool?
 
-        ThreadIdCB = FFI::Function.new(:ulong, []) do
-            Thread.current.object_id
-        end
+        #CRYPTO_LOCK = 0x1
+        #LockingCB = FFI::Function.new(:void, [:int, :int, :string, :int]) do |mode, type, file, line|
+        #    if (mode & CRYPTO_LOCK) != 0
+        #        SSL_LOCKS[type].lock
+        #    else
+                # Unlock a lock
+        #        SSL_LOCKS[type].unlock
+        #    end
+        #end
+        #ThreadIdCB = FFI::Function.new(:ulong, []) do
+        #    Thread.current.object_id
+        #end
 
 
         # INIT CODE
@@ -262,6 +289,29 @@ keystr
             CIPHERS = 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-RC4-SHA:ECDHE-RSA-AES128-SHA:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH:!CAMELLIA:@STRENGTH'.freeze
             SESSION = 'ruby-tls'.freeze
 
+
+            ALPN_LOOKUP = ThreadSafe::Cache.new
+            ALPN_Select_CB = FFI::Function.new(:int, [
+                # array of str, unit8 out,uint8 in,        *arg
+                :pointer, :pointer, :pointer, :string, :uint, :pointer
+            ]) do |ssl_p, out, outlen, inp, inlen, arg|
+                ssl = Box::InstanceLookup[ssl_p.address]
+                return SSL::SSL_TLSEXT_ERR_ALERT_FATAL unless ssl
+
+                protos = ssl.context.alpn_str
+                status = SSL.SSL_select_next_proto(out, outlen, protos, protos.length, inp, inlen)
+                ssl.negotiated
+
+                case status
+                when SSL::OPENSSL_NPN_UNSUPPORTED
+                    SSL::SSL_TLSEXT_ERR_ALERT_FATAL
+                when SSL::OPENSSL_NPN_NEGOTIATED
+                    SSL::SSL_TLSEXT_ERR_OK
+                when SSL::OPENSSL_NPN_NO_OVERLAP
+                    SSL::SSL_TLSEXT_ERR_ALERT_WARNING
+                end
+            end
+
             def initialize(server, options = {})
                 @is_server = server
                 @ssl_ctx = SSL.SSL_CTX_new(server ? SSL.SSLv23_server_method : SSL.SSLv23_client_method)
@@ -274,16 +324,27 @@ keystr
                 end
 
                 SSL.SSL_CTX_set_cipher_list(@ssl_ctx, options[:ciphers] || CIPHERS)
+                @alpn_set = false
 
                 if @is_server
                     SSL.SSL_CTX_sess_set_cache_size(@ssl_ctx, 128)
                     SSL.SSL_CTX_set_session_id_context(@ssl_ctx, SESSION, 8)
+
+                    if SSL::ALPN_SUPPORTED && options[:protocols]
+                        @alpn_str = Context.build_alpn_string(options[:protocols])
+                        SSL.SSL_CTX_set_alpn_select_cb(@ssl_ctx, ALPN_Select_CB, nil)
+                        @alpn_set = true
+                    end
                 else
                     set_private_key(options[:private_key])
                     set_certificate(options[:cert_chain])
-                end
 
-                # TODO:: Check for ALPN support
+                    # Check for ALPN support
+                    if SSL::ALPN_SUPPORTED && options[:protocols]
+                        protocols = Context.build_alpn_string(options[:protocols])
+                        @alpn_set = SSL.SSL_CTX_set_alpn_protos(@ssl_ctx, protocols, protocols.length) == 0
+                    end
+                end
             end
 
             def cleanup
@@ -295,11 +356,23 @@ keystr
 
             attr_reader :is_server
             attr_reader :ssl_ctx
+            attr_reader :alpn_set
+            attr_reader :alpn_str
 
 
             private
 
 
+            def self.build_alpn_string(protos)
+                protocols = ''.force_encoding('ASCII-8BIT')
+                protos.each do |prot|
+                    protocol = prot.to_s
+                    protocols << protocol.length
+                    protocols << protocol
+                end
+                protocols
+            end
+
             def set_private_key(key)
                 err = if key.is_a? FFI::Pointer
                     SSL.SSL_CTX_use_PrivateKey(@ssl_ctx, key)
@@ -338,6 +411,8 @@ keystr
 
 
         class Box
+            InstanceLookup = ThreadSafe::Cache.new
+
             READ_BUFFER = 2048
 
             SSL_VERIFY_PEER = 0x01
@@ -347,6 +422,7 @@ keystr
 
                 @handshake_completed = false
                 @handshake_signaled = false
+                @negotiated = false
                 @transport = transport
 
                 @read_buffer = FFI::MemoryPointer.new(:char, READ_BUFFER, false)
@@ -360,11 +436,9 @@ keystr
 
                 @write_queue = []
 
-                # TODO:: if server && options[:alpn_string]
-                # SSL_CTX_set_alpn_select_cb
-
                 InstanceLookup[@ssl.address] = self
 
+                @alpn_fallback = options[:fallback]
                 if options[:verify_peer]
                     SSL.SSL_set_verify(@ssl, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, VerifyCB)
                 end
@@ -374,6 +448,7 @@ keystr
 
 
             attr_reader :is_server
+            attr_reader :context
             attr_reader :handshake_completed
 
 
@@ -382,6 +457,22 @@ keystr
                 SSL.SSL_get_peer_certificate(@ssl)
             end
 
+            def negotiated_protocol
+                return nil unless @context.alpn_set
+
+                proto = FFI::MemoryPointer.new(:pointer, 1, true)
+                len = FFI::MemoryPointer.new(:uint, 1, true)
+                SSL.SSL_get0_alpn_selected(@ssl, proto, len)
+
+                resp = proto.get_pointer(0)
+                if resp.address == 0
+                    :failed
+                else
+                    length = len.get_uint(0)
+                    resp.read_string(length).to_sym
+                end
+            end
+
             def start
                 return unless @ready
 
@@ -435,7 +526,30 @@ keystr
 
             def signal_handshake
                 @handshake_signaled = true
-                @transport.handshake_cb
+
+                # Check protocol support here
+                if @context.alpn_set
+                    proto = negotiated_protocol
+
+                    if proto == :failed
+                        if @negotiated
+                            # We should shutdown if this is the case
+                            @transport.close_cb
+                            return
+                        elsif @alpn_fallback
+                            # Client or Server with a client that doesn't support ALPN
+                            proto = @alpn_fallback.to_sym
+                        end
+                    end
+                else
+                    proto = nil
+                end
+
+                @transport.handshake_cb(proto)
+            end
+
+            def negotiated
+                @negotiated = true
             end
 
             SSL_RECEIVED_SHUTDOWN = 2
@@ -474,8 +588,6 @@ keystr
                 end
             end
 
-
-            InstanceLookup = ThreadSafe::Cache.new
             VerifyCB = FFI::Function.new(:int, [:int, :pointer]) do |preverify_ok, x509_store|
                 x509 = SSL.X509_STORE_CTX_get_current_cert(x509_store)
                 ssl = SSL.X509_STORE_CTX_get_ex_data(x509_store, SSL.SSL_get_ex_data_X509_STORE_CTX_idx)

data/lib/ruby-tls/version.rb

@@ -1,3 +1,3 @@
 module RubyTls
-    VERSION = "2.0.1"
+    VERSION = "2.1.0"
 end

data/spec/alpn_spec.rb

@@ -0,0 +1,415 @@
+require 'ruby-tls'
+
+if RubyTls::SSL::ALPN_SUPPORTED
+
+    describe RubyTls do
+
+        describe RubyTls::SSL::Box do
+
+            it "should be able to negotiate a protocol" do
+                @server_data = []
+                @client_data = []
+                @interleaved = []
+
+
+                class Client3
+                    def initialize(client_data, interleaved)
+                        @client_data = client_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(false, self, {
+                            protocols: ["http/1.1", :h2]
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :stop
+                    attr_accessor :server
+
+                    def close_cb
+                        @client_data << 'client stopped'
+                        @interleaved << 'client stopped'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @client_data << data
+                        @interleaved << data
+                    end
+
+                    def transmit_cb(data)
+                        if not @server.started
+                            @server.started = true
+                            @server.ssl.start
+                        end
+                        @server.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @client_data << protocol
+                        @interleaved << 'client ready'
+
+                        sending = 'client request'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+                end
+
+
+                class Server3
+                    def initialize(client, server_data, interleaved)
+                        @client = client
+                        @server_data = server_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(true, self, {
+                            protocols: [:h2, "http/1.1"]
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :started
+                    attr_accessor :stop
+
+                    def close_cb
+                        @server_data << 'server stop'
+                        @interleaved << 'server stop'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @server_data << data
+                        @interleaved << data
+
+                        sending = 'server response'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+
+                    def transmit_cb(data)
+                        @client.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @server_data << protocol
+                        @interleaved << 'server ready'
+                    end
+                end
+
+
+                @client = Client3.new(@client_data, @interleaved)
+                @server = Server3.new(@client, @server_data, @interleaved)
+                @client.server = @server
+
+
+                @client.ssl.start
+                @client.ssl.cleanup
+                @server.ssl.cleanup
+
+                expect(@server_data).to eq([:h2, 'client request'])
+                expect(@client_data).to eq([:h2, 'server response'])
+                expect(@interleaved).to eq(['server ready', 'client ready', 'client request', 'server response'])
+            end
+
+
+            it "should stop the server when a protocol cannot be negotiated" do
+                @server_data = []
+                @client_data = []
+                @interleaved = []
+
+
+                class Client4
+                    def initialize(client_data, interleaved)
+                        @client_data = client_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(false, self, {
+                            protocols: ["h2c"]
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :stop
+                    attr_accessor :server
+
+                    def close_cb
+                        @client_data << 'client stopped'
+                        @interleaved << 'client stopped'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @client_data << data
+                        @interleaved << data
+                    end
+
+                    def transmit_cb(data)
+                        if not @server.started
+                            @server.started = true
+                            @server.ssl.start
+                        end
+                        @server.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @client_data << 'ready'
+                        @interleaved << 'client ready'
+
+                        sending = 'client request'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+                end
+
+
+                class Server4
+                    def initialize(client, server_data, interleaved)
+                        @client = client
+                        @server_data = server_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(true, self, {
+                            protocols: ["http/1.1", "h2"]
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :started
+                    attr_accessor :stop
+
+                    def close_cb
+                        @server_data << 'server stop'
+                        @interleaved << 'server stop'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @server_data << data
+                        @interleaved << data
+
+                        sending = 'server response'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+
+                    def transmit_cb(data)
+                        @client.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @server_data << 'ready'
+                        @interleaved << 'server ready'
+                    end
+                end
+
+
+                @client = Client4.new(@client_data, @interleaved)
+                @server = Server4.new(@client, @server_data, @interleaved)
+                @client.server = @server
+
+
+                @client.ssl.start
+                @client.ssl.cleanup
+                @server.ssl.cleanup
+
+                expect(@server_data).to eq(['server stop'])
+                expect(@client_data).to eq([])
+                expect(@interleaved).to eq(['server stop'])
+            end
+
+
+            it "should not stop the client if the server doesn't support ALPN" do
+                @server_data = []
+                @client_data = []
+                @interleaved = []
+
+
+                class Client5
+                    def initialize(client_data, interleaved)
+                        @client_data = client_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(false, self, {
+                            protocols: ["h2c"]
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :stop
+                    attr_accessor :server
+
+                    def close_cb
+                        @client_data << 'client stopped'
+                        @interleaved << 'client stopped'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @client_data << data
+                        @interleaved << data
+                    end
+
+                    def transmit_cb(data)
+                        if not @server.started
+                            @server.started = true
+                            @server.ssl.start
+                        end
+                        @server.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @client_data << protocol
+                        @interleaved << 'client ready'
+
+                        sending = 'client request'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+                end
+
+
+                class Server5
+                    def initialize(client, server_data, interleaved)
+                        @client = client
+                        @server_data = server_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(true, self)
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :started
+                    attr_accessor :stop
+
+                    def close_cb
+                        @server_data << 'server stop'
+                        @interleaved << 'server stop'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @server_data << data
+                        @interleaved << data
+
+                        sending = 'server response'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+
+                    def transmit_cb(data)
+                        @client.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @server_data << protocol
+                        @interleaved << 'server ready'
+                    end
+                end
+
+
+                @client = Client5.new(@client_data, @interleaved)
+                @server = Server5.new(@client, @server_data, @interleaved)
+                @client.server = @server
+
+
+                @client.ssl.start
+                @client.ssl.cleanup
+                @server.ssl.cleanup
+
+                expect(@client_data).to eq([:failed, 'server response'])
+                expect(@server_data).to eq([nil, 'client request'])
+                expect(@interleaved).to eq(['server ready', 'client ready', 'client request', 'server response'])
+            end
+
+
+            it "should not stop the server if the client doesn't support ALPN" do
+                @server_data = []
+                @client_data = []
+                @interleaved = []
+
+
+                class Client6
+                    def initialize(client_data, interleaved)
+                        @client_data = client_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(false, self)
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :stop
+                    attr_accessor :server
+
+                    def close_cb
+                        @client_data << 'client stopped'
+                        @interleaved << 'client stopped'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @client_data << data
+                        @interleaved << data
+                    end
+
+                    def transmit_cb(data)
+                        if not @server.started
+                            @server.started = true
+                            @server.ssl.start
+                        end
+                        @server.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @client_data << protocol
+                        @interleaved << 'client ready'
+
+                        sending = 'client request'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+                end
+
+
+                class Server6
+                    def initialize(client, server_data, interleaved)
+                        @client = client
+                        @server_data = server_data
+                        @interleaved = interleaved
+                        @ssl = RubyTls::SSL::Box.new(true, self, {
+                            protocols: ["h2", "http/1.1"],
+                            fallback: "http/1.1"
+                        })
+                    end
+
+                    attr_reader :ssl
+                    attr_accessor :started
+                    attr_accessor :stop
+
+                    def close_cb
+                        @server_data << 'server stop'
+                        @interleaved << 'server stop'
+                        @stop = true
+                    end
+
+                    def dispatch_cb(data)
+                        @server_data << data
+                        @interleaved << data
+
+                        sending = 'server response'
+                        @ssl.encrypt(sending) unless @stop
+                    end
+
+                    def transmit_cb(data)
+                        @client.ssl.decrypt(data) unless @stop
+                    end
+
+                    def handshake_cb(protocol)
+                        @server_data << protocol
+                        @interleaved << 'server ready'
+                    end
+                end
+
+
+                @client = Client6.new(@client_data, @interleaved)
+                @server = Server6.new(@client, @server_data, @interleaved)
+                @client.server = @server
+
+
+                @client.ssl.start
+                @client.ssl.cleanup
+                @server.ssl.cleanup
+
+
+                expect(@server_data).to eq([:"http/1.1", 'client request'])
+                expect(@client_data).to eq([nil, 'server response'])
+                expect(@interleaved).to eq(['server ready', 'client ready', 'client request', 'server response'])
+            end
+        end
+    end
+end

data/spec/comms_spec.rb

@@ -40,7 +40,7 @@ describe RubyTls do
                     @server.ssl.decrypt(data) unless @stop
                 end
 
-                def handshake_cb
+                def handshake_cb(protocol)
                     @client_data << 'ready'
                     @interleaved << 'client ready'
 
@@ -80,7 +80,7 @@ describe RubyTls do
                     @client.ssl.decrypt(data) unless @stop
                 end
 
-                def handshake_cb
+                def handshake_cb(protocol)
                     @server_data << 'ready'
                     @interleaved << 'server ready'
                 end

data/spec/verify_spec.rb

@@ -30,7 +30,7 @@ describe RubyTls do
             @server.ssl.decrypt(data) unless @stop
         end
 
-        def handshake_cb
+        def handshake_cb(protocol)
             @client_data << 'ready'
         end
     end
@@ -71,7 +71,7 @@ describe RubyTls do
                     @client.ssl.decrypt(data) unless @stop
                 end
 
-                def handshake_cb
+                def handshake_cb(protocol)
                     @server_data << 'ready'
                 end
 
@@ -126,7 +126,7 @@ describe RubyTls do
                     @client.ssl.decrypt(data) unless @stop
                 end
 
-                def handshake_cb
+                def handshake_cb(protocol)
                     @server_data << 'ready'
                 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-tls
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-07 00:00:00.000000000 Z
+date: 2015-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-compiler
@@ -80,6 +80,7 @@ files:
 - lib/ruby-tls/ssl.rb
 - lib/ruby-tls/version.rb
 - ruby-tls.gemspec
+- spec/alpn_spec.rb
 - spec/client.crt
 - spec/client.key
 - spec/comms_spec.rb
@@ -109,6 +110,7 @@ signing_key:
 specification_version: 4
 summary: Abstract TLS for Ruby
 test_files:
+- spec/alpn_spec.rb
 - spec/client.crt
 - spec/client.key
 - spec/comms_spec.rb