socket_duplex 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf86bc3bcc2e7134ebbb05833da75421b521d2f3
+  data.tar.gz: 716448a796d76653a9c27e376871428c041d7f17
+SHA512:
+  metadata.gz: b5f3fc1fda60758d11e2200e31fc737c40be0e02940cf5a9940e8bfe341183a79fb39189f0bb65f4fef2ed0b3fc74e4107a0a9e62885301e3a2be2f2c964a425
+  data.tar.gz: 6cf09a8a93af86ca0d38d153213c5ed1c5f8abb4b9ff7efcade7f26316b50b309c5155af58a0b6311f0c32057b79f6e5c3dd16abc58d88d7bc5652252efde873

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in get_test.gemspec
+gemspec

data/README.md

@@ -0,0 +1,15 @@
+# ruby-agent
+Secure Ruby on Rails with SECful.
+
+Installation
+------------
+    1. Add the following to your Gemfile:
+       gem 'socket_duplex', :git => 'git@github.com:SECful/ruby-agent.git'
+
+    2. Add the following to your config.ru:
+       require 'socket_duplex'
+       use Rack::SocketDuplex, 'wss://localhost:7000', 'token'
+
+       For a non SSL websocket use:
+       use Rack::SocketDuplex, 'ws://localhost:7000', 'token', OpenSSL::SSL::VERIFY_NONE
+

data/lib/socket_duplex.rb

@@ -0,0 +1,138 @@
+require 'json'
+require 'socket'
+require 'securerandom'
+
+require_relative 'websocket-client-simple'
+
+module Rack
+  class SocketDuplex
+    MAX_QUEUE_SIZE = 50
+    NUM_OF_THREADS = 5
+
+    def initialize(app, socket_path, secful_key, verify_mode=OpenSSL::SSL::VERIFY_PEER)
+      @app, @socket_path, @verify_mode = app, socket_path, verify_mode
+      begin
+        @secful_key = secful_key
+        @agent_identifier = SecureRandom.hex
+        @machine_ip = Socket.ip_address_list.detect(&:ipv4_private?).try(:ip_address)
+        @queue = SizedQueue.new(MAX_QUEUE_SIZE)
+        @threads_to_sockets = {}
+        Thread.new { activate_workers() }
+      rescue Exception
+      end
+    end
+
+    def call(env)
+      begin
+        dup._call(env)
+      rescue Exception
+        @app.call(env)
+      end
+    end
+
+    protected
+
+    def _call(env)
+      status, headers, body = @app.call(env)
+      if @queue.length < @queue.max
+        @queue << env
+      end
+      return [status, headers, body]
+    end
+
+    def activate_workers
+      NUM_OF_THREADS.times do
+        Thread.new {worker()}
+      end
+    end
+
+    def worker
+      loop do
+        env = @queue.pop
+        if env
+          connect_to_ws(Thread.current)
+          handle_request(env)
+        end rescue nil
+      end
+    end
+
+    def connect_to_ws(thr)
+      begin
+        ws = @threads_to_sockets[thr]
+        if !ws
+          headers = { 'Agent-Type' => 'Ruby',
+                      'Agent-Version' => '1.0',
+                      'Agent-Identifier' => @agent_identifier,
+                      'Authorization' => 'Bearer ' + @secful_key }
+          ws = WebSocket::Client::Simple.connect @socket_path, verify_mode: @verify_mode, headers: headers
+          sleep(3)
+        end
+        if !ws.open?
+          sleep(60)
+        end
+        if !ws.open?
+          ws.close()
+          ws = nil
+        end
+      rescue nil
+      end
+      @threads_to_sockets[thr] = ws
+    end
+
+    def handle_request(env)
+      request_hash = {}
+      if env['rack.url_scheme'] == 'http'
+        write_env(request_hash, env)
+        ws = @threads_to_sockets[Thread.current]
+        begin
+          ws.send request_hash.to_json
+        rescue Exception
+          if ws
+            ws.close()
+          end rescue nil
+          @threads_to_sockets[Thread.current] = nil
+        end
+      end rescue nil
+    end
+
+    def write_env(request_hash, env)
+      write_request_line request_hash, env
+      write_headers request_hash, env
+      write_post_body request_hash, env
+    end
+
+    def write_request_line(request_hash, env)
+      path_with_query_string = env['PATH_INFO']
+      path_with_query_string << "?#{env['QUERY_STRING']}" if env['QUERY_STRING'].length > 0
+      request_hash[:request] = {path: path_with_query_string,
+                                version: env['HTTP_VERSION'],
+                                method: env['REQUEST_METHOD']}
+      request_hash[:userSrcIp] = env['REMOTE_ADDR']
+      request_hash[:companyLocalIps] = [@machine_ip || env['SERVER_NAME']]
+    end
+
+    def write_headers(request_hash, env)
+      headers = env.select { |k, v| k =~ /^HTTP_/ }
+      headers = Hash[headers.map { |k, v| [k[5..-1].gsub('_', '-'), v] }]
+      headers.delete('VERSION')
+      if env['CONTENT_TYPE']
+        headers[:'CONTENT-TYPE'] = env['CONTENT_TYPE']
+      end
+      if env['CONTENT_LENGTH']
+        headers[:'CONTENT-LENGTH'] = env['CONTENT_LENGTH']
+      end
+
+      request_hash[:request][:headers] = headers_arr = []
+      headers.each do |k,v|
+        headers_arr << {key: k, value: v}
+      end
+    end
+
+    def write_post_body(request_hash, env)
+      if env['CONTENT_LENGTH'] && (content_length = env['CONTENT_LENGTH'].to_i) > 0
+        request_hash[:request][:payload] = env['rack.input'].read
+        env['rack.input'].rewind
+      end
+    end
+  end
+end

data/lib/websocket-client-simple/client.rb

@@ -0,0 +1,91 @@
+module WebSocket
+  module Client
+    module Simple
+
+      def self.connect(url, options={})
+        ::WebSocket::Client::Simple::Client.new(url, options)
+      end
+
+      class Client
+        include EventEmitter
+        attr_reader :url, :handshake
+
+        def initialize(url, options={})
+          @url = url
+          uri = URI.parse url
+          @socket = TCPSocket.new(uri.host,
+                                  uri.port || (uri.scheme == 'wss' ? 443 : 80))
+          if ['https', 'wss'].include? uri.scheme
+            ctx = OpenSSL::SSL::SSLContext.new
+            ctx.ssl_version = options[:ssl_version] || 'SSLv23'
+            ctx.verify_mode = options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE #use VERIFY_PEER for verification
+            cert_store = OpenSSL::X509::Store.new
+            cert_store.set_default_paths
+            ctx.cert_store = cert_store
+            @socket = ::OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+            @socket.connect
+          end
+          @handshake = ::WebSocket::Handshake::Client.new :url => url, :headers => options[:headers]
+          @handshaked = false
+          frame = ::WebSocket::Frame::Incoming::Client.new
+          @closed = false
+          once :__close do |err|
+            close
+            emit :close, err
+          end
+
+          @thread = Thread.new do
+            while !@closed do
+              begin
+                unless recv_data = @socket.getc
+                  sleep 1
+                  next
+                end
+                unless @handshaked
+                  @handshake << recv_data
+                  if @handshake.finished?
+                    @handshaked = true
+                    emit :open
+                  end
+                else
+                  frame << recv_data
+                  while msg = frame.next
+                    emit :message, msg
+                  end
+                end
+              rescue => e
+                emit :error, e
+              end
+            end
+          end
+
+          @socket.write @handshake.to_s
+        end
+
+        def send(data, opt={:type => :text})
+          return if !@handshaked or @closed
+          type = opt[:type]
+          frame = ::WebSocket::Frame::Outgoing::Client.new(:data => data, :type => type, :version => @handshake.version)
+          #begin
+          @socket.write frame.to_s
+          #rescue Errno::EPIPE => e
+          #  emit :__close, e
+          #end
+        end
+
+        def close
+          @closed = true
+          @socket.close if @socket
+          @socket = nil
+          Thread.kill @thread if @thread
+        end
+
+        def open?
+          @handshake.finished? and !@closed
+        end
+
+      end
+
+    end
+  end
+end

data/lib/websocket-client-simple/version.rb

@@ -0,0 +1,7 @@
+module WebSocket
+  module Client
+    module Simple
+      VERSION = "0.2.4"
+    end
+  end
+end

data/lib/websocket-client-simple.rb

@@ -0,0 +1,15 @@
+require 'event_emitter'
+require 'websocket'
+require 'socket'
+require 'openssl'
+require 'uri'
+
+require 'websocket-client-simple/version'
+require 'websocket-client-simple/client'
+
+module WebSocket
+  module Client
+    module Simple
+    end
+  end
+end

data/socket_duplex.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "socket_duplex"
+  spec.version       = '1.0.0'
+  spec.authors       = ["Secful"]
+  spec.description   = %q{Rack middleware that duplexes HTTP traffic}
+  spec.summary       = spec.description
+
+  spec.files         = `git ls-files`.split($/).reject{|f| f == "Gemfile.lock" }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "websocket-eventmachine-server"
+  spec.add_development_dependency "eventmachine"
+
+  spec.add_runtime_dependency "websocket"
+  spec.add_runtime_dependency "event_emitter"
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: socket_duplex
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Secful
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-server
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: event_emitter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rack middleware that duplexes HTTP traffic
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/socket_duplex.rb
+- lib/websocket-client-simple.rb
+- lib/websocket-client-simple/client.rb
+- lib/websocket-client-simple/version.rb
+- socket_duplex.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Rack middleware that duplexes HTTP traffic
+test_files: []