httpi-adapter-win32sspi 0.0.1.rc1-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5c8d1eafaeeef8bcf09d2c83ab3d2668ed414b7
+  data.tar.gz: aaf878b1c5f1efb4cf77889c9c78748a31e82d18
+SHA512:
+  metadata.gz: fdaf85e6b0d6046e20e45c973df115d6fd34e1d62f51e4ed7bd600b9b86ac3e38dd762755e5d97ab74754293de4dc8217fa80777ada178c37dd01d513ec14acd
+  data.tar.gz: cfb7844536b4b8b569447fa361476fd269356ed9d131cee7cb33b5145d26c4f63e11741da2fd422c95ba7476c76a6594092fc07d562c0ea0a1ba32ca0b0e4e43

data/License.txt

@@ -0,0 +1,8 @@
+MIT License
+Copyright (c) 2015 Gary Sick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rubygems'
+require 'rubygems/package'
+
+CLEAN.include('**/*.gem')
+
+namespace :gem do
+  desc "Create the httpi-adapter-win32sspi gem"
+  task :create => [:clean] do
+    spec = eval(IO.read('httpi_adapter_win32sspi.gemspec'))
+    Gem::Package.build(spec)
+  end
+
+  desc "Install the httpi-adapter-win32sspi gem"
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file} -l --no-document"
+  end
+end
+
+namespace :test do
+  Rake::TestTask.new(:win32_adapter) do |t|
+    t.test_files = FileList['test/test_httpi_adapter_win32sspi.rb']
+    t.verbose = true
+  end
+
+  Rake::TestTask.new(:httpi_auth) do |t|
+    t.test_files = FileList['test/test_httpi_auth.rb']
+    t.verbose = true
+  end
+
+  Rake::TestTask.new(:all) do |t|
+    t.test_files = FileList['test/test_httpi*']
+    t.verbose = true
+  end
+end
+
+task :default => 'test:all'

data/Readme.md

@@ -0,0 +1,7 @@
+This project provides a Win32 SSPI adapter implementation for HTTPI
+
+The example directory has a working example to illustrate usage.
+
+The provided adapter is dependent on the Win32-SSPI gem available
+at this site.
+

data/example/httpi_adapter_client.rb

@@ -0,0 +1,22 @@
+require 'pp'
+require 'httpi'
+require 'httpi-adapter-win32sspi'
+
+class HttpiAdapterClient
+  def self.run(url)
+    uri = URI.parse(url)
+    request = HTTPI::Request.new(url)
+    request.auth.sspi(spn:"HTTP/#{uri.host}")
+    response = HTTPI::get(request, :win32_sspi)
+    pp response
+  end
+end
+
+if __FILE__ == $0
+  if ARGV.length < 1
+    puts "usage: ruby httpi_adapter_client url"
+    exit(0)
+  end
+
+  HttpiAdapterClient.run(ARGV[0])
+end

data/httpi_adapter_win32sspi.gemspec

@@ -0,0 +1,26 @@
+require 'rubygems'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'httpi-adapter-win32sspi'
+  spec.summary    = 'A HTTPI Adapter the uses Win32SSPI'
+  spec.version    = '0.0.1.rc1'
+  spec.author     = 'Gary Sick'
+  spec.license    = 'MIT'
+  spec.email      = 'garys361@gmail.com'
+  spec.platform   = Gem::Platform::CURRENT
+  spec.required_ruby_version = '>=1.9'
+  spec.homepage   = 'https://github.com/garysick/httpi_adapter_win32sspi'
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') || f.include?('Notes.txt') }
+  spec.test_files = Dir['test/*.rb']
+  spec.has_rdoc   = false
+
+  spec.add_dependency('win32-sspi', '=0.0.1.rc1')
+  spec.add_development_dependency('test-unit','~>3.0')
+  spec.requirements << "This gem will only work in a Windows Environment"
+
+  spec.description = <<-EOF
+    A HTTPI Adapter the uses Win32SSPI library.
+    Support the Negotiate protocols.
+    See examples for usage.
+  EOF
+end

data/lib/httpi-adapter-win32sspi.rb

@@ -0,0 +1,2 @@
+require_relative "httpi/auth/config_sspi"
+require_relative "httpi/adapter/win32sspi"

data/lib/httpi/adapter/win32sspi.rb

@@ -0,0 +1,136 @@
+require 'base64'
+require 'httpi'
+require 'net/http'
+require 'win32-sspi'
+require 'negotiate/client'
+require_relative '../auth/config_sspi'
+
+module HTTPI
+  module Adapter
+    class Win32SSPI < Base
+      register :win32_sspi
+      
+      def initialize(req)
+        @request = req
+        @sspi_client = create_sspi_client(req)
+        @client = create_http_client(req)
+      end
+      
+      attr_reader :client
+      attr_reader :sspi_client
+      
+      def request(method)
+        unless REQUEST_METHODS.include? method
+          raise NotSupportedError, "Net::HTTP does not support custom HTTP methods"
+        end
+
+        http_req = convert_to_http_request(method,@request)
+        response = dispatch_request(@client, @sspi_client, http_req)
+        convert_to_httpi_response(response)
+      end
+      
+      private
+      
+      def create_sspi_client(request)
+        return nil unless :sspi == request.auth.type
+        
+        options = request.auth.sspi.first
+        Win32::SSPI::Negotiate::Client.new(options)
+      end
+      
+      def create_http_client(request)
+        if request.auth.digest?
+          raise NotSupportedError, "Net::HTTP does not support HTTP digest authentication"
+        end
+
+        if request.proxy
+          http = Net::HTTP.new(request.url.host, request.url.port,
+            request.proxy.host, request.proxy.port, request.proxy.user, request.proxy.password)
+        else
+          http = Net::HTTP.new(request.url.host, request.url.port)
+        end
+
+        http.open_timeout = request.open_timeout if request.open_timeout
+        http.read_timeout = request.read_timeout if request.read_timeout
+
+        if request.auth.ssl?
+          ssl = request.auth.ssl
+          unless ssl.verify_mode == :none
+            http.ca_file = ssl.ca_cert_file if ssl.ca_cert_file
+          end
+
+          http.key = ssl.cert_key
+          http.cert = ssl.cert
+
+          http.verify_mode = ssl.openssl_verify_mode
+          http.ssl_version = ssl.ssl_version if ssl.ssl_version
+        end
+        
+        http
+      end
+      
+      def dispatch_request(http_client,sspi_client,http_req)
+        if sspi_client
+          perform_authenticated_request(http_client,sspi_client,http_req)
+        else
+          perform_http_request(http_client,http_req)
+        end
+      end
+      
+      def perform_authenticated_request(http_client,sspi_client,http_req)
+        http_resp = nil
+        http_client.start do |http|
+          sspi_client.http_authenticate do |header|
+            http_req['Authorization'] = header
+            http_resp = perform_request(http,http_req)
+            http_resp['www-authenticate']
+          end
+        end
+        http_resp
+      end
+      
+      def perform_http_request(http_client,http_req)
+        http_resp = nil
+        http_client.start do |http|
+          http_resp = perform_request(http,http_req)
+        end
+        http_resp
+      end
+      
+      def perform_request(http,http_req)
+        if @request.on_body
+          http.request(http_req) do |r|
+            r.read_body do |seg|
+              @request.on_body.call(seg)
+            end
+          end
+        else
+          http.request(http_req)
+        end
+      end
+      
+      def convert_to_http_request(type,req)
+        request_class = case type
+          when :get    then Net::HTTP::Get
+          when :post   then Net::HTTP::Post
+          when :head   then Net::HTTP::Head
+          when :put    then Net::HTTP::Put
+          when :delete then Net::HTTP::Delete
+        end
+
+        request = request_class.new(req.url, req.headers)
+        request.body = req.body
+        request
+      end
+      
+      def convert_to_httpi_response(resp)
+        headers = resp.to_hash
+        headers.each do |key, value|
+          headers[key] = value[0] if value.size <= 1
+        end
+        body = (resp.body.kind_of?(Net::ReadAdapter) ? "" : resp.body)
+        Response.new(resp.code, headers, body)
+      end
+    end
+  end
+end

data/lib/httpi/auth/config_sspi.rb

@@ -0,0 +1,22 @@
+require 'httpi/auth/config'
+
+module ConfigSSPI
+  def self.included(mod)
+    if HTTPI::Auth::Config == mod
+      mod::TYPES << :sspi unless mod::TYPES.include?(:sspi)
+    end
+  end
+  
+  def sspi(*args)
+    return @sspi if args.empty?
+    
+    @sspi = args.flatten.compact
+    @type = :sspi
+  end
+
+  def sspi?
+    @type == :sspi
+  end
+end
+
+HTTPI::Auth::Config.include(ConfigSSPI)

data/test/all_tests.rb

@@ -0,0 +1,2 @@
+require_relative 'test_httpi_auth'
+require_relative 'test_httpi_adapter_win32sspi'

data/test/test_httpi_adapter_win32sspi.rb

@@ -0,0 +1,260 @@
+require 'httpi'
+require 'httpi/adapter/win32sspi'
+require 'test-unit'
+
+HTTPI.log = false
+
+class TC_HttpiAdapterWin32SSPI < Test::Unit::TestCase
+  RequestURI = "http://virtual-server.gas.local:3005/test"
+  RequestSPN = "HTTP/virtual-server.gas.local"
+  TestHeaderName = "Test-Header"
+  TestHeader = "some junk"
+  RemoteUserHdrName = "Remote-User"
+  RemoteUserHdr = "johny d"
+  FakeAuth = 'YIIxckdlsleodllsleoeoo49dldleo490'
+  AuthenticateHdrName = "www-authenticate"
+  AuthenticateHdr = "Negotiate #{FakeAuth}"
+  AuthorizationHdrName = "Authorization"
+  AuthorizationHdr = AuthenticateHdr
+  MockRespSegments = ["Segment 1","Segment 2","Segment 3"]
+  
+  def test_load_adapter
+    request = HTTPI::Request.new(RequestURI)
+    request.auth.sspi(spn:RequestSPN)
+    adapter = HTTPI.send(:load_adapter,:win32_sspi,request)
+    assert_equal "HTTPI::Adapter::Win32SSPI", adapter.class.name
+    assert_equal "Win32::SSPI::Negotiate::Client", adapter.sspi_client.class.name
+    assert_equal URI.parse(RequestURI), request.url
+  end
+  
+  def with_mock_adapter(adapter_klass = create_mock_adapter)
+    HTTPI::Adapter.register(:win32_sspi, adapter_klass, {})
+
+    yield adapter_klass if block_given?
+
+  ensure
+    HTTPI::Adapter.register(:win32_sspi,HTTPI::Adapter::Win32SSPI,{})
+  end
+  
+  def assert_request_response_attributes(request,response,adapter_klass)
+    assert_equal 'HTTPI::Response', response.class.name
+    assert_equal 200, response.code
+    assert_equal 'hello test', response.body unless request.on_body
+    assert_equal 1, response.headers.size
+    assert_equal AuthenticateHdr, response.headers[AuthenticateHdrName]
+
+    assert_equal request, adapter_klass.read_state(:httpi_request)
+    
+    sspi_client = adapter_klass.read_state(:sspi_client)
+    if sspi_client
+      assert_equal "Win32::SSPI::Negotiate::Client", sspi_client.class.name
+      assert_equal 'Negotiate', sspi_client.auth_type
+      assert_equal RequestSPN, sspi_client.spn
+    end
+
+    http_req = adapter_klass.read_state(:http_request)
+    assert_equal "virtual-server.gas.local", http_req.uri.host
+    assert_equal 3005, http_req.uri.port
+    assert_equal "/test", http_req.uri.path
+    
+    yield(http_req) if block_given?
+    
+    assert_equal TestHeader, http_req[TestHeaderName]
+    assert_equal RemoteUserHdr, http_req[RemoteUserHdrName]
+  end
+
+  def test_get
+    with_mock_adapter do |adapter_klass|
+      request = HTTPI::Request.new(RequestURI)
+      request.auth.sspi(spn:RequestSPN)
+      request.headers[TestHeaderName] = TestHeader
+      request.headers[RemoteUserHdrName] = RemoteUserHdr
+
+      response = HTTPI::get(request, :win32_sspi)
+      
+      assert_request_response_attributes(request,response,adapter_klass) do |http_req|
+        assert_equal 'Net::HTTP::Get', http_req.class.name
+        assert_equal 3, adapter_klass.read_state(:perform_authenticated_request_args).length
+        assert_nil adapter_klass.read_state(:perform_http_request_args)
+      end
+    end
+  end
+
+  def test_get_with_query_parameter
+    with_mock_adapter do |adapter_klass|
+      request = HTTPI::Request.new(RequestURI)
+      request.auth.sspi(spn:RequestSPN)
+      request.query ="q=query"
+      request.headers[TestHeaderName] = TestHeader
+      request.headers[RemoteUserHdrName] = RemoteUserHdr
+
+      response = HTTPI::get(request, :win32_sspi)
+      
+      assert_request_response_attributes(request,response,adapter_klass) do |http_req|
+        assert_equal 'Net::HTTP::Get', http_req.class.name
+        assert_equal "q=query", http_req.uri.query
+        assert_equal 3, adapter_klass.read_state(:perform_authenticated_request_args).length
+        assert_nil adapter_klass.read_state(:perform_http_request_args)
+      end
+    end
+  end
+
+  def test_post
+    with_mock_adapter do |adapter_klass|
+      request = HTTPI::Request.new(RequestURI)
+      request.auth.sspi(spn:RequestSPN)
+      request.body = "firstname=tom&lastname=johnson"
+      request.headers[TestHeaderName] = TestHeader
+      request.headers[RemoteUserHdrName] = RemoteUserHdr
+
+      response = HTTPI::post(request, :win32_sspi)
+      
+      assert_request_response_attributes(request,response,adapter_klass) do |http_req|
+        assert_equal 'Net::HTTP::Post', http_req.class.name
+        assert_equal "firstname=tom&lastname=johnson", http_req.body
+        assert_equal 3, adapter_klass.read_state(:perform_authenticated_request_args).length
+        assert_nil adapter_klass.read_state(:perform_http_request_args)
+      end
+    end
+  end
+
+  def test_request_without_sspi_client
+    with_mock_adapter do |adapter_klass|
+      request = HTTPI::Request.new(RequestURI)
+      request.headers[TestHeaderName] = TestHeader
+      request.headers[RemoteUserHdrName] = RemoteUserHdr
+
+      response = HTTPI::get(request, :win32_sspi)
+
+      assert_request_response_attributes(request,response,adapter_klass) do |http_req|
+        assert_equal 'Net::HTTP::Get', http_req.class.name
+        assert_nil adapter_klass.read_state(:sspi_client)
+        assert_equal 2, adapter_klass.read_state(:perform_http_request_args).length
+        assert_nil adapter_klass.read_state(:perform_authenticated_request_args)
+      end
+    end
+  end
+
+  def test_get_with_request_block
+    with_mock_adapter do |adapter_klass|
+      request = HTTPI::Request.new(RequestURI)
+      request.auth.sspi(spn:RequestSPN)
+      request.headers[TestHeaderName] = TestHeader
+      request.headers[RemoteUserHdrName] = RemoteUserHdr
+      response_segments = []
+      request.on_body do |seg|
+        response_segments << seg
+      end
+
+      response = HTTPI::get(request, :win32_sspi)
+      
+      assert_request_response_attributes(request,response,adapter_klass) do |http_req|
+        assert_equal 'Net::HTTP::Get', http_req.class.name
+        assert_equal 3, adapter_klass.read_state(:perform_authenticated_request_args).length
+        assert_nil adapter_klass.read_state(:perform_http_request_args)
+        
+        assert_equal 3, response_segments.length
+        assert_equal MockRespSegments, response_segments
+      end
+    end
+  end
+
+  def create_mock_adapter
+    Class.new(MockWin32SSPIAdapter)
+  end
+end
+
+class MockWin32SSPIAdapter < HTTPI::Adapter::Win32SSPI
+  def create_sspi_client(request)
+    sspi_client = super
+    if sspi_client
+      self.class.capture_state(:sspi_client,sspi_client)
+      sspi_client = self
+    end
+    sspi_client
+  end
+  
+  def http_authenticate
+    yield(TC_HttpiAdapterWin32SSPI::AuthorizationHdr) if block_given?
+  end
+  
+  def create_http_client(request)
+    self.class.capture_state(:httpi_request,request)
+    self
+  end
+  
+  def perform_authenticated_request(*args)
+    self.class.capture_state(:perform_authenticated_request_args,args)
+    super
+  end
+  
+  def perform_http_request(*args)
+    self.class.capture_state(:perform_http_request_args,args)
+    super
+  end
+  
+  def start
+    yield self if block_given?
+  end
+  
+  def request(req)
+    return super if req.kind_of?(Symbol)
+
+    self.class.capture_state(:http_request, req)
+
+    segmented_body = false
+    if block_given?
+      yield self
+      segmented_body = true
+    end
+    
+    self.class.create_mock_response(segmented_body)
+  end
+  
+  def read_body(dest=nil,&segment_handler)
+    if segment_handler
+      3.times do |ii|
+        segment_handler.call(TC_HttpiAdapterWin32SSPI::MockRespSegments[ii])
+      end
+    end
+  end
+  
+  def self.state
+    @state ||= Hash.new
+  end
+
+  def self.capture_state(key,value)
+    state[key] = value
+  end
+
+  def self.read_state(key)
+    state[key]
+  end
+
+  def self.create_mock_response(segmented_body=false)
+    resp = Class.new(::Hash) do
+      def code
+        @code ||= 200
+      end
+      def code=(rhs)
+        @code = rhs
+      end
+      def body
+        @body ||= ""
+      end
+      def body=(rhs)
+        @body = rhs
+      end
+      def headers
+        self
+      end
+      def to_hash
+        self
+      end
+    end.new
+
+    resp.body = "hello test" unless segmented_body
+    resp[TC_HttpiAdapterWin32SSPI::AuthenticateHdrName] = [TC_HttpiAdapterWin32SSPI::AuthenticateHdr]
+    resp
+  end
+end

data/test/test_httpi_auth.rb

@@ -0,0 +1,17 @@
+require 'httpi'
+require 'httpi/auth/config_sspi'
+require 'test-unit'
+
+HTTPI.log = false
+
+class TC_HttpiAuth < Test::Unit::TestCase
+  def test_auth_sspi
+    req = HTTPI::Request.new("http://virttual-server.gas.local:3005/test")
+    req.auth.sspi( {:spn => "HTTP/virtual-server.gas.local"} )
+    
+    assert req.auth.sspi?
+    refute req.auth.sspi.empty?
+    assert_equal "HTTP/virtual-server.gas.local", req.auth.sspi.first[:spn]
+    assert HTTPI::Auth::Config::TYPES.include?(:sspi)
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: httpi-adapter-win32sspi
+version: !ruby/object:Gem::Version
+  version: 0.0.1.rc1
+platform: x86-mingw32
+authors:
+- Gary Sick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: win32-sspi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.rc1
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+      A HTTPI Adapter the uses Win32SSPI library.
+      Support the Negotiate protocols.
+      See examples for usage.
+email: garys361@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- License.txt
+- Rakefile
+- Readme.md
+- example/httpi_adapter_client.rb
+- httpi_adapter_win32sspi.gemspec
+- lib/httpi-adapter-win32sspi.rb
+- lib/httpi/adapter/win32sspi.rb
+- lib/httpi/auth/config_sspi.rb
+- test/all_tests.rb
+- test/test_httpi_adapter_win32sspi.rb
+- test/test_httpi_auth.rb
+homepage: https://github.com/garysick/httpi_adapter_win32sspi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements:
+- This gem will only work in a Windows Environment
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A HTTPI Adapter the uses Win32SSPI
+test_files:
+- test/all_tests.rb
+- test/test_httpi_adapter_win32sspi.rb
+- test/test_httpi_auth.rb