RubyGems - ruby-openid2 - Versions diffs - 3.0.0 - Mend

ruby-openid2 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

checksums.yaml +7 -0
checksums.yaml.gz.sig +0 -0
data/CHANGELOG.md +136 -0
data/CODE_OF_CONDUCT.md +84 -0
data/CONTRIBUTING.md +54 -0
data/LICENSE.txt +210 -0
data/README.md +81 -0
data/SECURITY.md +15 -0
data/lib/hmac/hmac.rb +110 -0
data/lib/hmac/sha1.rb +11 -0
data/lib/hmac/sha2.rb +25 -0
data/lib/openid/association.rb +246 -0
data/lib/openid/consumer/associationmanager.rb +354 -0
data/lib/openid/consumer/checkid_request.rb +179 -0
data/lib/openid/consumer/discovery.rb +516 -0
data/lib/openid/consumer/discovery_manager.rb +144 -0
data/lib/openid/consumer/html_parse.rb +142 -0
data/lib/openid/consumer/idres.rb +513 -0
data/lib/openid/consumer/responses.rb +147 -0
data/lib/openid/consumer/session.rb +36 -0
data/lib/openid/consumer.rb +406 -0
data/lib/openid/cryptutil.rb +112 -0
data/lib/openid/dh.rb +84 -0
data/lib/openid/extension.rb +38 -0
data/lib/openid/extensions/ax.rb +552 -0
data/lib/openid/extensions/oauth.rb +88 -0
data/lib/openid/extensions/pape.rb +170 -0
data/lib/openid/extensions/sreg.rb +268 -0
data/lib/openid/extensions/ui.rb +49 -0
data/lib/openid/fetchers.rb +277 -0
data/lib/openid/kvform.rb +113 -0
data/lib/openid/kvpost.rb +62 -0
data/lib/openid/message.rb +555 -0
data/lib/openid/protocolerror.rb +7 -0
data/lib/openid/server.rb +1571 -0
data/lib/openid/store/filesystem.rb +260 -0
data/lib/openid/store/interface.rb +73 -0
data/lib/openid/store/memcache.rb +109 -0
data/lib/openid/store/memory.rb +79 -0
data/lib/openid/store/nonce.rb +72 -0
data/lib/openid/trustroot.rb +597 -0
data/lib/openid/urinorm.rb +72 -0
data/lib/openid/util.rb +119 -0
data/lib/openid/version.rb +5 -0
data/lib/openid/yadis/accept.rb +141 -0
data/lib/openid/yadis/constants.rb +16 -0
data/lib/openid/yadis/discovery.rb +151 -0
data/lib/openid/yadis/filters.rb +192 -0
data/lib/openid/yadis/htmltokenizer.rb +290 -0
data/lib/openid/yadis/parsehtml.rb +50 -0
data/lib/openid/yadis/services.rb +44 -0
data/lib/openid/yadis/xrds.rb +160 -0
data/lib/openid/yadis/xri.rb +86 -0
data/lib/openid/yadis/xrires.rb +87 -0
data/lib/openid.rb +27 -0
data/lib/ruby-openid.rb +1 -0
data.tar.gz.sig +0 -0
metadata +331 -0
metadata.gz.sig +0 -0

data/lib/openid/util.rb ADDED Viewed

@@ -0,0 +1,119 @@
+require "cgi"
+require "uri"
+require "logger"
+# See OpenID::Consumer or OpenID::Server modules, as well as the store classes
+module OpenID
+  class AssertionError < Exception
+  end
+  # Exceptions that are raised by the library are subclasses of this
+  # exception type, so if you want to catch all exceptions raised by
+  # the library, you can catch OpenIDError
+  class OpenIDError < StandardError
+  end
+  module Util
+    BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
+      "abcdefghijklmnopqrstuvwxyz0123456789+/"
+    BASE64_RE = Regexp.compile(
+      "
+    \\A
+    ([#{BASE64_CHARS}]{4})*
+    ([#{BASE64_CHARS}]{2}==|
+     [#{BASE64_CHARS}]{3}=)?
+    \\Z",
+      Regexp::EXTENDED,
+    )
+    def self.truthy_assert(value, message = nil)
+      return if value
+      raise AssertionError, message or value
+    end
+    def self.to_base64(s)
+      [s].pack("m").delete("\n")
+    end
+    def self.from_base64(s)
+      without_newlines = s.gsub(/[\r\n]+/, "")
+      raise ArgumentError, "Malformed input: #{s.inspect}" unless BASE64_RE.match(without_newlines)
+      without_newlines.unpack1("m")
+    end
+    def self.urlencode(args)
+      a = []
+      args.each do |key, val|
+        if val.nil?
+          val = ""
+        elsif !!val == val
+          # it's boolean let's convert it to string representation
+          # or else CGI::escape won't like it
+          val = val.to_s
+        end
+        a << (CGI.escape(key) + "=" + CGI.escape(val))
+      end
+      a.join("&")
+    end
+    def self.parse_query(qs)
+      query = {}
+      CGI.parse(qs).each { |k, v| query[k] = v[0] }
+      query
+    end
+    def self.append_args(url, args)
+      url = url.dup
+      return url if args.length == 0
+      args = args.sort if args.respond_to?(:each_pair)
+      url << (url.include?("?") ? "&" : "?")
+      url << Util.urlencode(args)
+    end
+    @@logger = Logger.new(STDERR)
+    @@logger.progname = "OpenID"
+    def self.logger=(logger)
+      @@logger = logger
+    end
+    def self.logger
+      @@logger
+    end
+    # change the message below to do whatever you like for logging
+    def self.log(message)
+      logger.info(message)
+    end
+    def self.auto_submit_html(form, title = "OpenID transaction in progress")
+      "
+<html>
+<head>
+  <title>#{title}</title>
+</head>
+<body onload='document.forms[0].submit();'>
+#{form}
+<script>
+var elements = document.forms[0].elements;
+for (var i = 0; i < elements.length; i++) {
+  elements[i].style.display = \"none\";
+}
+</script>
+</body>
+</html>
+"
+    end
+    ESCAPE_TABLE = {"&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;", "'" => "&#039;"}
+    # Modified from ERb's html_encode
+    def self.html_encode(str)
+      str.to_s.gsub(/[&<>"']/) { |s| ESCAPE_TABLE[s] }
+    end
+  end
+end

data/lib/openid/version.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module OpenID
+  module Version
+    VERSION = "3.0.0"
+  end
+end

data/lib/openid/yadis/accept.rb ADDED Viewed

@@ -0,0 +1,141 @@
+module OpenID
+  module Yadis
+    # Generate an accept header value
+    #
+    # [str or (str, float)] -> str
+    def self.generate_accept_header(*elements)
+      parts = []
+      elements.each do |element|
+        if element.is_a?(String)
+          qs = "1.0"
+          mtype = element
+        else
+          mtype, q = element
+          q = q.to_f
+          raise ArgumentError.new("Invalid preference factor: #{q}") if q > 1 or q <= 0
+          qs = format("%0.1f", q)
+        end
+        parts << [qs, mtype]
+      end
+      parts.sort!
+      chunks = []
+      parts.each do |q, mtype|
+        chunks << if q == "1.0"
+          mtype
+        else
+          format("%s; q=%s", mtype, q)
+        end
+      end
+      chunks.join(", ")
+    end
+    def self.parse_accept_header(value)
+      # Parse an accept header, ignoring any accept-extensions
+      #
+      # returns a list of tuples containing main MIME type, MIME
+      # subtype, and quality markdown.
+      #
+      # str -> [(str, str, float)]
+      chunks = value.split(",", -1).collect { |v| v.strip }
+      accept = []
+      chunks.each do |chunk|
+        parts = chunk.split(";", -1).collect { |s| s.strip }
+        mtype = parts.shift
+        if mtype.index("/").nil?
+          # This is not a MIME type, so ignore the bad data
+          next
+        end
+        main, sub = mtype.split("/", 2)
+        q = nil
+        parts.each do |ext|
+          unless ext.index("=").nil?
+            k, v = ext.split("=", 2)
+            q = v.to_f if k == "q"
+          end
+        end
+        q = 1.0 if q.nil?
+        accept << [q, main, sub]
+      end
+      accept.sort!
+      accept.reverse!
+      accept.collect { |q, main, sub| [main, sub, q] }
+    end
+    def self.match_types(accept_types, have_types)
+      # Given the result of parsing an Accept: header, and the
+      # available MIME types, return the acceptable types with their
+      # quality markdowns.
+      #
+      # For example:
+      #
+      # >>> acceptable = parse_accept_header('text/html, text/plain; q=0.5')
+      # >>> matchTypes(acceptable, ['text/plain', 'text/html', 'image/jpeg'])
+      # [('text/html', 1.0), ('text/plain', 0.5)]
+      #
+      # Type signature: ([(str, str, float)], [str]) -> [(str, float)]
+      default = if accept_types.nil? or accept_types == []
+        # Accept all of them
+        1
+      else
+        0
+      end
+      match_main = {}
+      match_sub = {}
+      accept_types.each do |main, sub, q|
+        if main == "*"
+          default = [default, q].max
+          next
+        elsif sub == "*"
+          match_main[main] = [match_main.fetch(main, 0), q].max
+        else
+          match_sub[[main, sub]] = [match_sub.fetch([main, sub], 0), q].max
+        end
+      end
+      accepted_list = []
+      order_maintainer = 0
+      have_types.each do |mtype|
+        main, sub = mtype.split("/", 2)
+        q = if match_sub.member?([main, sub])
+          match_sub[[main, sub]]
+        else
+          match_main.fetch(main, default)
+        end
+        if q != 0
+          accepted_list << [1 - q, order_maintainer, q, mtype]
+          order_maintainer += 1
+        end
+      end
+      accepted_list.sort!
+      accepted_list.collect { |_, _, q, mtype| [mtype, q] }
+    end
+    def self.get_acceptable(accept_header, have_types)
+      # Parse the accept header and return a list of available types
+      # in preferred order. If a type is unacceptable, it will not be
+      # in the resulting list.
+      #
+      # This is a convenience wrapper around matchTypes and
+      # parse_accept_header
+      #
+      # (str, [str]) -> [str]
+      accepted = parse_accept_header(accept_header)
+      preferred = match_types(accepted, have_types)
+      preferred.collect { |mtype, _| mtype }
+    end
+  end
+end

data/lib/openid/yadis/constants.rb ADDED Viewed

@@ -0,0 +1,16 @@
+require_relative "accept"
+module OpenID
+  module Yadis
+    YADIS_HEADER_NAME = "X-XRDS-Location"
+    YADIS_CONTENT_TYPE = "application/xrds+xml"
+    # A value suitable for using as an accept header when performing
+    # YADIS discovery, unless the application has special requirements
+    YADIS_ACCEPT_HEADER = generate_accept_header(
+      ["text/html", 0.3],
+      ["application/xhtml+xml", 0.5],
+      [YADIS_CONTENT_TYPE, 1.0],
+    )
+  end
+end

data/lib/openid/yadis/discovery.rb ADDED Viewed

@@ -0,0 +1,151 @@
+require_relative "../util"
+require_relative "../fetchers"
+require_relative "constants"
+require_relative "parsehtml"
+module OpenID
+  # Raised when a error occurs in the discovery process
+  class DiscoveryFailure < OpenIDError
+    attr_accessor :identity_url, :http_response
+    def initialize(message, http_response)
+      super(message)
+      @identity_url = nil
+      @http_response = http_response
+    end
+  end
+  module Yadis
+    # Contains the result of performing Yadis discovery on a URI
+    class DiscoveryResult
+      # The result of following redirects from the request_uri
+      attr_accessor :normalize_uri
+      # The URI from which the response text was returned (set to
+      # nil if there was no XRDS document found)
+      attr_accessor :xrds_uri
+      # The content-type returned with the response_text
+      attr_accessor :content_type
+      # The document returned from the xrds_uri
+      attr_accessor :response_text
+      attr_accessor :request_uri, :normalized_uri
+      def initialize(request_uri)
+        # Initialize the state of the object
+        #
+        # sets all attributes to None except the request_uri
+        @request_uri = request_uri
+        @normalized_uri = nil
+        @xrds_uri = nil
+        @content_type = nil
+        @response_text = nil
+      end
+      # Was the Yadis protocol's indirection used?
+      def used_yadis_location?
+        @normalized_uri != @xrds_uri
+      end
+      # Is the response text supposed to be an XRDS document?
+      def is_xrds
+        (used_yadis_location? or
+                @content_type == YADIS_CONTENT_TYPE)
+      end
+    end
+    # Discover services for a given URI.
+    #
+    # uri: The identity URI as a well-formed http or https URI. The
+    # well-formedness and the protocol are not checked, but the
+    # results of this function are undefined if those properties do
+    # not hold.
+    #
+    # returns a DiscoveryResult object
+    #
+    # Raises DiscoveryFailure when the HTTP response does not have
+    # a 200 code.
+    def self.discover(uri)
+      result = DiscoveryResult.new(uri)
+      begin
+        resp = OpenID.fetch(uri, nil, {"Accept" => YADIS_ACCEPT_HEADER})
+      rescue Exception
+        raise DiscoveryFailure.new("Failed to fetch identity URL #{uri} : #{$!}", $!)
+      end
+      if resp.code != "200" and resp.code != "206"
+        raise DiscoveryFailure.new(
+          'HTTP Response status from identity URL host is not "200".' \
+            "Got status #{resp.code.inspect} for #{resp.final_url}",
+          resp,
+        )
+      end
+      # Note the URL after following redirects
+      result.normalized_uri = resp.final_url
+      # Attempt to find out where to go to discover the document or if
+      # we already have it
+      result.content_type = resp["content-type"]
+      result.xrds_uri = where_is_yadis?(resp)
+      if result.xrds_uri and result.used_yadis_location?
+        begin
+          resp = OpenID.fetch(result.xrds_uri)
+        rescue StandardError
+          raise DiscoveryFailure.new("Failed to fetch Yadis URL #{result.xrds_uri} : #{$!}", $!)
+        end
+        if resp.code != "200" and resp.code != "206"
+          exc = DiscoveryFailure.new(
+            'HTTP Response status from Yadis host is not "200". ' +
+                                 "Got status #{resp.code.inspect} for #{resp.final_url}",
+            resp,
+          )
+          exc.identity_url = result.normalized_uri
+          raise exc
+        end
+        result.content_type = resp["content-type"]
+      end
+      result.response_text = resp.body
+      result
+    end
+    # Given a HTTPResponse, return the location of the Yadis
+    # document.
+    #
+    # May be the URL just retrieved, another URL, or None, if I
+    # can't find any.
+    #
+    # [non-blocking]
+    def self.where_is_yadis?(resp)
+      # Attempt to find out where to go to discover the document or if
+      # we already have it
+      content_type = resp["content-type"]
+      # According to the spec, the content-type header must be an
+      # exact match, or else we have to look for an indirection.
+      if !content_type.nil? and !content_type.to_s.empty? and
+          content_type.split(";", 2)[0].downcase == YADIS_CONTENT_TYPE
+        return resp.final_url
+      else
+        # Try the header
+        yadis_loc = resp[YADIS_HEADER_NAME.downcase]
+        if yadis_loc.nil?
+          # Parse as HTML if the header is missing.
+          #
+          # XXX: do we want to do something with content-type, like
+          # have a whitelist or a blacklist (for detecting that it's
+          # HTML)?
+          yadis_loc = Yadis.html_yadis_location(resp.body)
+        end
+      end
+      yadis_loc
+    end
+  end
+end

data/lib/openid/yadis/filters.rb ADDED Viewed

@@ -0,0 +1,192 @@
+# This file contains functions and classes used for extracting
+# endpoint information out of a Yadis XRD file using the REXML
+# XML parser.
+module OpenID
+  module Yadis
+    class BasicServiceEndpoint
+      attr_reader :type_uris, :yadis_url, :uri, :service_element
+      # Generic endpoint object that contains parsed service
+      # information, as well as a reference to the service element
+      # from which it was generated. If there is more than one
+      # xrd:Type or xrd:URI in the xrd:Service, this object represents
+      # just one of those pairs.
+      #
+      # This object can be used as a filter, because it implements
+      # fromBasicServiceEndpoint.
+      #
+      # The simplest kind of filter you can write implements
+      # fromBasicServiceEndpoint, which takes one of these objects.
+      def initialize(yadis_url, type_uris, uri, service_element)
+        @type_uris = type_uris
+        @yadis_url = yadis_url
+        @uri = uri
+        @service_element = service_element
+      end
+      # Query this endpoint to see if it has any of the given type
+      # URIs. This is useful for implementing other endpoint classes
+      # that e.g. need to check for the presence of multiple
+      # versions of a single protocol.
+      def match_types(type_uris)
+        @type_uris & type_uris
+      end
+      # Trivial transform from a basic endpoint to itself. This
+      # method exists to allow BasicServiceEndpoint to be used as a
+      # filter.
+      #
+      # If you are subclassing this object, re-implement this function.
+      def self.from_basic_service_endpoint(endpoint)
+        endpoint
+      end
+      # A hack to make both this class and its instances respond to
+      # this message since Ruby doesn't support static methods.
+      def from_basic_service_endpoint(endpoint)
+        self.class.from_basic_service_endpoint(endpoint)
+      end
+    end
+    # Take a list of basic filters and makes a filter that
+    # transforms the basic filter into a top-level filter. This is
+    # mostly useful for the implementation of make_filter, which
+    # should only be needed for special cases or internal use by
+    # this library.
+    #
+    # This object is useful for creating simple filters for services
+    # that use one URI and are specified by one Type (we expect most
+    # Types will fit this paradigm).
+    #
+    # Creates a BasicServiceEndpoint object and apply the filter
+    # functions to it until one of them returns a value.
+    class TransformFilterMaker
+      attr_reader :filter_procs
+      # Initialize the filter maker's state
+      #
+      # filter_functions are the endpoint transformer
+      # Procs to apply to the basic endpoint. These are called in
+      # turn until one of them does not return nil, and the result
+      # of that transformer is returned.
+      def initialize(filter_procs)
+        @filter_procs = filter_procs
+      end
+      # Returns an array of endpoint objects produced by the
+      # filter procs.
+      def get_service_endpoints(yadis_url, service_element)
+        endpoints = []
+        # Do an expansion of the service element by xrd:Type and
+        # xrd:URI
+        Yadis.expand_service(service_element).each do |type_uris, uri, _|
+          # Create a basic endpoint object to represent this
+          # yadis_url, Service, Type, URI combination
+          endpoint = BasicServiceEndpoint.new(
+            yadis_url, type_uris, uri, service_element
+          )
+          e = apply_filters(endpoint)
+          endpoints << e unless e.nil?
+        end
+        endpoints
+      end
+      def apply_filters(endpoint)
+        # Apply filter procs to an endpoint until one of them returns
+        # non-nil.
+        @filter_procs.each do |filter_proc|
+          e = filter_proc.call(endpoint)
+          unless e.nil?
+            # Once one of the filters has returned an endpoint, do not
+            # apply any more.
+            return e
+          end
+        end
+        nil
+      end
+    end
+    class CompoundFilter
+      attr_reader :subfilters
+      # Create a new filter that applies a set of filters to an
+      # endpoint and collects their results.
+      def initialize(subfilters)
+        @subfilters = subfilters
+      end
+      # Generate all endpoint objects for all of the subfilters of
+      # this filter and return their concatenation.
+      def get_service_endpoints(yadis_url, service_element)
+        endpoints = []
+        @subfilters.each do |subfilter|
+          endpoints += subfilter.get_service_endpoints(yadis_url, service_element)
+        end
+        endpoints
+      end
+    end
+    # Exception raised when something is not able to be turned into a
+    # filter
+    @@filter_type_error = TypeError.new(
+      "Expected a filter, an endpoint, a callable or a list of any of these.",
+    )
+    # Convert a filter-convertable thing into a filter
+    #
+    # parts should be a filter, an endpoint, a callable, or a list of
+    # any of these.
+    def self.make_filter(parts)
+      # Convert the parts into a list, and pass to mk_compound_filter
+      parts = [BasicServiceEndpoint] if parts.nil?
+      return mk_compound_filter(parts) if parts.is_a?(Array)
+      mk_compound_filter([parts])
+    end
+    # Create a filter out of a list of filter-like things
+    #
+    # Used by make_filter
+    #
+    # parts should be a list of things that can be passed to make_filter
+    def self.mk_compound_filter(parts)
+      raise TypeError, "#{parts.inspect} is not iterable" unless parts.respond_to?(:each)
+      # Separate into a list of callables and a list of filter objects
+      transformers = []
+      filters = []
+      parts.each do |subfilter|
+        if !subfilter.is_a?(Array)
+          # If it's not an iterable
+          if subfilter.respond_to?(:get_service_endpoints)
+            # It's a full filter
+            filters << subfilter
+          elsif subfilter.respond_to?(:from_basic_service_endpoint)
+            # It's an endpoint object, so put its endpoint conversion
+            # attribute into the list of endpoint transformers
+            transformers << subfilter.method(:from_basic_service_endpoint)
+          elsif subfilter.respond_to?(:call)
+            # It's a proc, so add it to the list of endpoint
+            # transformers
+            transformers << subfilter
+          else
+            raise @@filter_type_error
+          end
+        else
+          filters << mk_compound_filter(subfilter)
+        end
+      end
+      filters << TransformFilterMaker.new(transformers) if transformers.length > 0
+      return filters[0] if filters.length == 1
+      CompoundFilter.new(filters)
+    end
+  end
+end