abiquo-etk 0.4.13

data/vendor/httpauth-0.1/Rakefile

@@ -0,0 +1,76 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+NAME = 'httpauth'
+VERSIE = '0.1' 
+RDOC_OPTS = ['--quiet', '--title', "HTTPAuth - A Ruby library for creating, parsing and validating HTTP authentication headers",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--charset", "utf-8",
+    "--inline-source"]
+CLEAN.include ['pkg', 'doc', '*.gem']
+
+desc 'Default: run tests'
+task :default => [:test]
+task :package => [:clean]
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end
+
+desc 'Create documentation'
+Rake::RDocTask.new("doc") do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README"
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Upload rdoc documentation to Rubyforge'
+task :upload_doc => :doc do
+  `scp -r #{File.dirname(__FILE__)}/doc/* mst@rubyforge.org:/var/www/gforge-projects/httpauth/`
+end
+
+spec =
+    Gem::Specification.new do |s|
+        s.name = NAME
+        s.version = VERSIE
+        s.platform = Gem::Platform::RUBY
+        s.has_rdoc = true
+        s.extra_rdoc_files = ["README", "LICENSE"]
+        s.rdoc_options += RDOC_OPTS + ['--exclude', '^(examples|test)\/']
+        s.summary = "Library for the HTTP Authentication protocol (RFC 2617)"
+        s.description = "HTTPauth is a library supporting the full HTTP Authentication protocol as specified in RFC 2617; both Digest Authentication and Basic Authentication."
+        s.author = "Manfred Stienstra"
+        s.email = 'manfred@fngtps.com'
+        s.homepage = 'http://httpauth.rubyforge.org'
+        s.required_ruby_version = '>= 1.8.0'
+
+        s.files = %w(README LICENSE Rakefile) +
+          Dir.glob("lib/**/*") + 
+          Dir.glob("examples/**/*")
+        
+        s.require_path = "lib"
+    end
+
+Rake::GemPackageTask.new(spec) do |p|
+    p.need_tar = true
+    p.gem_spec = spec
+end
+
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERSIE}}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end

data/vendor/httpauth-0.1/examples/client_digest_secure

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems' rescue LoadError
+require 'uri'
+require 'rfuzz/client'
+require 'httpauth/digest'
+
+SALT = 'My very very secret salt'
+
+class AuthenticationCache
+  
+  def initialize
+    @uri = nil
+    @credentials = nil
+  end
+  
+  def set_credentials_for(uri, credentials)
+    @uri = get_new_uri(@uri, uri)
+    @credentials = credentials
+  end
+  
+  def get_credentials
+    @credentials
+  end
+  
+  def update_usage_for(uri, nextnonce=nil)
+    if nextnonce
+      @credentials.nc = nextnonce
+    else
+      @credentials.nc += 1
+    end
+  end
+  
+  protected
+  
+  # Is uri1 more general than uri2
+  def more_general_uri?(uri1, uri2)
+    ua1 = uri1.nil? ? [] : uri1.split('/')
+    ua2 = uri2.nil? ? [] : uri2.split('/')
+    ua1.each_with_index do |p, i|
+      return false unless ua2[i] == p
+    end
+    true
+  end
+  
+  def get_new_uri(uri1, uri2)
+    if more_general_uri?(uri1, uri2)
+      uri1
+    else
+      uri2
+    end
+  end
+end
+
+class AuthenticatedClient
+  include HTTPAuth::Digest
+  
+  def initialize(host, port)
+    @client = RFuzz::HttpClient.new host, port
+    @cache = AuthenticationCache.new
+    @username = nil
+    @password = nil
+  end
+  
+  def get_credentials_from_user
+    if @username.nil?
+      print 'Username: '
+      @username = $stdin.gets.strip
+    end
+    if @password.nil?
+      print 'Password: '
+      @password = $stdin.gets.strip
+    end
+    [@username, @password]
+  end
+  
+  # Get a resource from the server
+  def get(resource)
+    uri = URI.parse resource
+    
+    # If credentials were stored, use them. Otherwise do a normal get
+    credentials = @cache.get_credentials
+    unless credentials.nil?
+      puts "sending credentials: #{credentials.to_header}"
+      response = @client.get resource, :head => {"Authorization" => credentials.to_header}
+    else
+      response = @client.get resource
+    end
+    # If response was 401, retry with authentication
+    if response.http_status == '401' and !response['WWW_AUTHENTICATE'].nil?
+      puts "got challenge: #{response['WWW_AUTHENTICATE']}"
+      challenge = Challenge.from_header(response['WWW_AUTHENTICATE'])
+      (stale = challenge.stale) rescue NoMethodError
+      unless stale
+        username, password = get_credentials_from_user
+      else
+        username = credentials.username
+        password = credentials.password
+      end
+      credentials = Credentials.from_challenge(challenge,
+        {:uri => resource, :username => username, :password => password, :method => 'GET'}
+      )
+      puts "sending credentials: #{credentials.to_header}"
+      @cache.set_credentials_for uri.path, credentials
+      response = @client.get resource, :head => {"Authorization" => credentials.to_header}
+    end
+    # If the server sends authentication info use the information for the next request
+    if response['AUTHENTICATION_INFO']
+      puts "got authentication-info: #{response['AUTHENTICATION_INFO']}"
+      auth_info = AuthenticationInfo.from_header(response['AUTHENTICATION_INFO'])
+      @cache.update_usage_for uri.path, auth_info.h[:nextnonce]
+    else
+      @cache.update_usage_for uri.path
+    end
+    response
+  end
+end
+
+if $0 == __FILE__
+  unless ARGV.length == 2
+    puts <<-EOT
+Usage: client_digest_secure get <url>
+    EOT
+    exit 0
+  end
+  uri = URI.parse ARGV[1]
+  client = AuthenticatedClient.new uri.host, uri.port
+  response = client.send ARGV[0].intern, uri.query ? "#{uri.path}&#{uri.query}" : uri.path
+  puts response.http_body
+end

data/vendor/httpauth-0.1/examples/server_digest_secure

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'webrick'
+require 'httpauth/digest'
+require 'yaml'
+
+include WEBrick
+
+s = HTTPServer.new :Port => 2000, :AccessLog => [[File.open('/dev/null', 'w'), AccessLog::COMMON_LOG_FORMAT],
+  [File.open('/dev/null', 'w'), AccessLog::REFERER_LOG_FORMAT]]
+
+class AuthenticationServlet < HTTPServlet::AbstractServlet
+  include HTTPAuth::Digest
+  def do_GET(request, response)
+    puts '-'*79
+    puts "request: Authorization: " + (request['Authorization'] || '')
+    
+    credentials = Credentials.from_header(request['Authorization']) unless request['Authorization'].nil?
+    if !credentials.nil? and credentials.validate :password => 'secret', :method => 'GET'
+      response.status = 200
+      auth_info = AuthenticationInfo.from_credentials credentials
+      response['Authentication-Info'] = auth_info.to_header
+      response['Content-Type'] = 'text/plain; charset=utf-8'
+      response.body  = 'You are authorized'
+      puts "response: Authentication-Info: " + response['Authentication-Info']
+    else
+      if credentials
+        puts '[!] FAILED: ' + credentials.reason
+      else
+        puts '[!] FAILED: No credentials specified'
+      end
+      response.status = 401
+      challenge = Challenge.new :realm => 'admin@httpauth.example.com', :qop => ['auth']
+      response['WWW-Authenticate'] = challenge.to_header
+      response['Content-Type'] = 'text/plain; charset=utf-8'
+      response.body  = 'You are not authorized'
+      puts "response: WWW-Authenticate: " + response['WWW-Authenticate']
+    end
+  end
+end
+
+puts "\n>>> Open http://localhost:2000/ and login with password 'secret', any username should work\n\n"
+s.mount '/', AuthenticationServlet
+trap('INT') { s.shutdown }
+s.start

data/vendor/httpauth-0.1/lib/httpauth/basic.rb

@@ -0,0 +1,114 @@
+%w(base64 httpauth/exceptions httpauth/constants).each { |l| require l }
+
+module HTTPAuth
+  # = Basic
+  #
+  # The Basic class provides a number of methods to handle HTTP Basic Authentication. In Basic Authentication
+  # the server sends a challenge and the client has to respond to that with the correct credentials. These
+  # credentials will have to be sent with every request from that point on.
+  #
+  # == On the server 
+  #
+  # On the server you will have to check the headers for the 'Authorization' header. When you find one unpack
+  # it and check it against your database of credentials. If the credentials are wrong you have to return a
+  # 401 status message and a challenge, otherwise proceed as normal. The code is meant as an example, not as
+  # runnable code.
+  #
+  #   def check_authentication(request, response)
+  #     credentials = HTTPAuth::Basic.unpack_authorization(request['Authorization'])
+  #     if ['admin', 'secret'] == credentials
+  #       response.status = 200
+  #       return true
+  #     else
+  #       response.status = 401
+  #       response['WWW-Authenticate'] = HTTPAuth::Basic.pack_challenge('Admin Pages')
+  #       return false
+  #     end
+  #   end
+  #
+  # == On the client
+  #
+  # On the client you have to detect the WWW-Authenticate header sent from the server. Once you find one you _should_
+  # send credentials for that resource any resource 'deeper in the URL space'. You _may_ send the credentials for
+  # every request without a WWW-Authenticate challenge. Note that credentials are valid for a realm, a server can
+  # use multiple realms for different resources. The code is meant as an example, not as runnable code.
+  #
+  #   def get_credentials_from_user_for(realm)
+  #     if realm == 'Admin Pages'
+  #      return ['admin', 'secret']
+  #     else
+  #      return [nil, nil]
+  #     end
+  #   end
+  #
+  #   def handle_authentication(response, request)
+  #     unless response['WWW-Authenticate'].nil?
+  #       realm = HTTPAuth::Basic.unpack_challenge(response['WWW-Authenticate])
+  #       @credentials[realm] ||= get_credentials_from_user_for(realm)
+  #       @last_realm = realm
+  #     end
+  #     unless @last_realm.nil?
+  #       request['Authorization'] = HTTPAuth::Basic.pack_authorization(*@credentials[@last_realm])
+  #     end
+  #   end
+  class Basic
+    class << self
+      
+      # Unpacks the HTTP Basic 'Authorization' credential header
+      #
+      # * <tt>authorization</tt>: The contents of the Authorization header
+      # * Returns a list with two items: the username and password
+      def unpack_authorization(authorization) 
+        d = authorization.split ' '
+        raise ArgumentError.new("HTTPAuth::Basic can only unpack Basic Authentication headers") unless d[0] == 'Basic'
+        Base64.decode64(d[1]).split(':')[0..1]
+      end
+      
+      # Packs HTTP Basic credentials to an 'Authorization' header
+      #
+      # * <tt>username</tt>: A string with the username
+      # * <tt>password</tt>: A string with the password
+      def pack_authorization(username, password)
+        "Basic %s" % Base64.encode64("#{username}:#{password}").gsub("\n", '')
+      end
+      
+      # Returns contents for the WWW-authenticate header
+      #
+      # * <tt>realm</tt>: A string with a recognizable title for the restricted resource
+      def pack_challenge(realm)
+        "Basic realm=\"%s\"" % realm.gsub('"', '')
+      end
+      
+      # Returns the name of the realm in a WWW-Authenticate header
+      #
+      # * <tt>authenticate</tt>: The contents of the WWW-Authenticate header
+      def unpack_challenge(authenticate)
+        if authenticate =~ /Basic\srealm=\"([^\"]*)\"/
+          return $1
+        else
+          if authenticate =~ /^Basic/
+            raise UnwellformedHeader.new("Can't parse the WWW-Authenticate header, it's probably not well formed")
+          else
+            raise ArgumentError.new("HTTPAuth::Basic can only unpack Basic Authentication headers")
+          end
+        end
+      end
+      
+      # Finds and unpacks the authorization credentials in a hash with the CGI enviroment. Returns [nil,nil] if no
+      # credentials were found. See HTTPAuth::CREDENTIAL_HEADERS for supported variable names.
+      #
+      # _Note for Apache_: normally the Authorization header can be found in the HTTP_AUTHORIZATION env variable,
+      # but Apache's mod_auth removes the variable from the enviroment. You can work around this by renaming
+      # the variable in your apache configuration (or .htaccess if allowed). For example: rewrite the variable
+      # for every request on /admin/*.
+      #
+      #   RewriteEngine on
+      #   RewriteRule ^admin/ - [E=X-HTTP-AUTHORIZATION:%{HTTP:Authorization}]
+      def get_credentials(env)
+        d = HTTPAuth::CREDENTIAL_HEADERS.inject(false) { |d,h| env[h] || d }
+        return unpack_authorization(d) if d
+        [nil, nil]
+      end
+    end
+  end
+end

data/vendor/httpauth-0.1/lib/httpauth/constants.rb

@@ -0,0 +1,14 @@
+# HTTPAuth holds a number of classes and constants to implement HTTP Authentication with. See Basic or Digest for
+# details on how to implement authentication using this library.
+#
+# For more information see RFC 2617 (http://www.ietf.org/rfc/rfc2617.txt)
+module HTTPAuth
+  VERSION = '0.1'
+  
+  CREDENTIAL_HEADERS = %w{REDIRECT_X_HTTP_AUTHORIZATION X-HTTP-AUTHORIZATION X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION}
+  SUPPORTED_SCHEMES = { :basic => 'Basic', :digest => 'Digest' }
+  SUPPORTED_QOPS = ['auth', 'auth-int']
+  SUPPORTED_ALGORITHMS = ['MD5', 'MD5-sess']
+  PREFERRED_QOP = 'auth'
+  PREFERRED_ALGORITHM = 'MD5'
+end