mongo 2.24.0 → 2.25.0

data/lib/mongo/uri.rb

@@ -141,6 +141,19 @@ module Mongo
     # @since 2.5.0
     SCHEME_DELIM = '://'
 
+    # Placeholder used in place of cleartext credentials when a URI is
+    # rendered for display, logging, or error reporting.
+    CREDENTIALS_PLACEHOLDER = '<credentials>'
+
+    # Pattern matching the userinfo portion of a MongoDB connection string.
+    # Anchors at the start and is bounded to the authority component (stops at
+    # the first '/', '?', or '#'), but matches greedily up to the last '@' in
+    # that component so passwords containing an unescaped '@' are still fully
+    # redacted. Case-insensitive so an unusual scheme like 'MongoDB://' is
+    # redacted too — the parser will reject it, and the redactor must not be
+    # the thing that leaks the credentials in the resulting error.
+    USERINFO_REDACTION_REGEX = %r{\A(mongodb(?:\+srv)?://)[^/?#]*@}i.freeze
+
     # Error details for an invalid options format.
     #
     # @since 2.1.0
@@ -215,6 +228,24 @@ module Mongo
     # @since 2.1.0
     REPEATABLE_OPTIONS = %i[tag_sets ssl]
 
+    # Replace the userinfo portion of a MongoDB connection string with a
+    # placeholder so the result can safely be logged, displayed, or embedded
+    # in an exception message.
+    #
+    # The input is matched as a string, not parsed, so this is safe to call
+    # on malformed URIs (which is exactly when {InvalidURI} is raised).
+    #
+    # @param [ String ] string The raw URI string.
+    #
+    # @return [ String ] The URI with any userinfo replaced by
+    #   {CREDENTIALS_PLACEHOLDER}, or the input unchanged if it is not a
+    #   string or has no userinfo.
+    def self.redact(string)
+      return string unless string.is_a?(String)
+
+      string.sub(USERINFO_REDACTION_REGEX, "\\1#{CREDENTIALS_PLACEHOLDER}@")
+    end
+
     # Get either a URI object or a SRVProtocol URI object.
     #
     # @example Get the uri object.
@@ -320,20 +351,33 @@ module Mongo
       @database || Database::ADMIN
     end
 
-    # Get the uri as a string.
+    # Get the uri as a string with any credentials redacted.
+    #
+    # Credentials are replaced with {CREDENTIALS_PLACEHOLDER} so the result is
+    # safe to log or display. Use {#credentials} to recover the original user
+    # and password.
     #
     # @example Get the uri as a string.
     #   uri.to_s
     #
-    # @return [ String ] The uri string.
+    # @return [ String ] The redacted uri string.
     def to_s
       reconstruct_uri
     end
 
+    # Return a redacted, human-readable representation of the URI. The
+    # default {Object#inspect} would dump {@string} and {@password} as
+    # instance variables, leaking credentials.
+    #
+    # @return [ String ] The redacted inspect string.
+    def inspect
+      "#<#{self.class.name}: #{reconstruct_uri}>"
+    end
+
     private
 
-    # Reconstruct the URI from its parts. Invalid options are dropped and options
-    # are converted to camelCase.
+    # Reconstruct the URI from its parts with credentials redacted. Invalid
+    # options are dropped and options are converted to camelCase.
     #
     # @return [ String ] the uri.
     def reconstruct_uri
@@ -349,9 +393,7 @@ module Mongo
       end.compact.join('&')
 
       uri = "#{scheme}#{SCHEME_DELIM}"
-      uri += @user.to_s if @user
-      uri += "#{AUTH_USER_PWD_DELIM}#{@password}" if @password
-      uri += '@' if @user || @password
+      uri += "#{CREDENTIALS_PLACEHOLDER}@" if @user || @password
       uri += @query_hostname || servers
       uri += '/' if @database || !options.empty?
       uri += @database.to_s if @database
@@ -418,7 +460,7 @@ module Mongo
     end
 
     def parse_user!(string)
-      if string && user = string.partition(AUTH_USER_PWD_DELIM)[0]
+      if string && (user = string.partition(AUTH_USER_PWD_DELIM)[0])
         raise_invalid_error!(UNESCAPED_USER_PWD) if UNSAFE.match?(user)
         user_decoded = decode(user)
         raise_invalid_error!(UNESCAPED_USER_PWD) if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
@@ -461,6 +503,12 @@ module Mongo
       # 'tls' and 'ssl'. In order to fulfill this, we parse the values of each instance into an
       # array; assuming all values in the array are the same, we replace the array with that value.
       unless uri_options[:ssl].nil? || uri_options[:ssl].empty?
+        # A nil element means an invalid value (e.g. tls=yes) was supplied.
+        # Refuse it rather than silently connecting over plaintext (RUBY-3832).
+        if uri_options[:ssl].include?(nil)
+          raise_invalid_error_no_fmt!("invalid boolean value for 'tls' or 'ssl'; only 'true' and 'false' are accepted")
+        end
+
         unless uri_options[:ssl].uniq.length == 1
           raise_invalid_error_no_fmt!("all instances of 'tls' and 'ssl' must have the same value")
         end

data/lib/mongo/utils.rb

@@ -73,7 +73,7 @@ module Mongo
     # @note server_api must have symbol keys or be a BSON::Document.
     module_function def transform_server_api(server_api)
       {}.tap do |doc|
-        if version = server_api[:version]
+        if (version = server_api[:version])
           doc['apiVersion'] = version
         end
         doc['apiStrict'] = server_api[:strict] unless server_api[:strict].nil?

data/lib/mongo/version.rb

@@ -5,5 +5,5 @@ module Mongo
   #
   # Note that this file is automatically updated via `rake candidate:create`.
   # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '2.24.0'
+  VERSION = '2.25.0'
 end

data/lib/mongo.rb

@@ -101,6 +101,7 @@ module Mongo
     delegate_option Config, :broken_view_options
     delegate_option Config, :validate_update_replace
     delegate_option Config, :csfle_convert_to_ruby_types
+    delegate_option Config, :include_server_address_in_errors
   end
 
   # Clears the driver's OCSP response cache.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 2.24.0
+  version: 2.25.0
 platform: ruby
 authors:
 - The MongoDB Ruby Team
@@ -90,8 +90,6 @@ files:
 - lib/mongo/auth/stringprep.rb
 - lib/mongo/auth/stringprep/profiles/sasl.rb
 - lib/mongo/auth/stringprep/tables.rb
-- lib/mongo/auth/stringprep/unicode_normalize/normalize.rb
-- lib/mongo/auth/stringprep/unicode_normalize/tables.rb
 - lib/mongo/auth/user.rb
 - lib/mongo/auth/user/view.rb
 - lib/mongo/auth/x509.rb
@@ -191,6 +189,7 @@ files:
 - lib/mongo/cursor/nontailable.rb
 - lib/mongo/cursor_host.rb
 - lib/mongo/database.rb
+- lib/mongo/database/cursor_command_view.rb
 - lib/mongo/database/view.rb
 - lib/mongo/dbref.rb
 - lib/mongo/deprecations.rb
@@ -369,6 +368,9 @@ files:
 - lib/mongo/operation/create_search_indexes/op_msg.rb
 - lib/mongo/operation/create_user.rb
 - lib/mongo/operation/create_user/op_msg.rb
+- lib/mongo/operation/cursor_command.rb
+- lib/mongo/operation/cursor_command/op_msg.rb
+- lib/mongo/operation/cursor_command/result.rb
 - lib/mongo/operation/delete.rb
 - lib/mongo/operation/delete/bulk_result.rb
 - lib/mongo/operation/delete/op_msg.rb
@@ -559,7 +561,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Ruby driver for MongoDB
 test_files: []

data/lib/mongo/auth/stringprep/unicode_normalize/normalize.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright Ayumu Nojima (野島 歩) and Martin J. Dürst (duerst@it.aoyama.ac.jp)
-
-# This file, the companion file tables.rb (autogenerated), and the module,
-# constants, and method defined herein are part of the implementation of the
-# built-in String class, not part of the standard library. They should
-# therefore never be gemified. They implement the methods
-# String#unicode_normalize, String#unicode_normalize!, and String#unicode_normalized?.
-#
-# They are placed here because they are written in Ruby. They are loaded on
-# demand when any of the three methods mentioned above is executed for the
-# first time. This reduces the memory footprint and startup time for scripts
-# and applications that do not use those methods.
-#
-# The name and even the existence of the module UnicodeNormalize and all of its
-# content are purely an implementation detail, and should not be exposed in
-# any test or spec or otherwise.
-
-require 'mongo/auth/stringprep/unicode_normalize/tables'
-
-# @api private
-module UnicodeNormalize # :nodoc:
-  ## Constant for max hash capacity to avoid DoS attack
-  MAX_HASH_LENGTH = 18_000 # enough for all test cases, otherwise tests get slow
-
-  ## Regular Expressions and Hash Constants
-  REGEXP_D = Regexp.compile(REGEXP_D_STRING, Regexp::EXTENDED)
-  REGEXP_C = Regexp.compile(REGEXP_C_STRING, Regexp::EXTENDED)
-  REGEXP_K = Regexp.compile(REGEXP_K_STRING, Regexp::EXTENDED)
-  NF_HASH_D = Hash.new do |hash, key|
-    hash.shift if hash.length > MAX_HASH_LENGTH # prevent DoS attack
-    hash[key] = nfd_one(key)
-  end
-  NF_HASH_C = Hash.new do |hash, key|
-    hash.shift if hash.length > MAX_HASH_LENGTH # prevent DoS attack
-    hash[key] = nfc_one(key)
-  end
-
-  ## Constants For Hangul
-  # for details such as the meaning of the identifiers below, please see
-  # http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf, pp. 144/145
-  SBASE = 0xAC00
-  LBASE = 0x1100
-  VBASE = 0x1161
-  TBASE = 0x11A7
-  LCOUNT = 19
-  VCOUNT = 21
-  TCOUNT = 28
-  NCOUNT = VCOUNT * TCOUNT
-  SCOUNT = LCOUNT * NCOUNT
-
-  # Unicode-based encodings (except UTF-8)
-  UNICODE_ENCODINGS = [ Encoding::UTF_16BE, Encoding::UTF_16LE, Encoding::UTF_32BE, Encoding::UTF_32LE,
-                        Encoding::GB18030, Encoding::UCS_2BE, Encoding::UCS_4BE ]
-
-  ## Hangul Algorithm
-  def self.hangul_decomp_one(target)
-    syllable_index = target.ord - SBASE
-    return target if syllable_index < 0 || syllable_index >= SCOUNT
-
-    l = LBASE + (syllable_index / NCOUNT)
-    v = VBASE + ((syllable_index % NCOUNT) / TCOUNT)
-    t = TBASE + (syllable_index % TCOUNT)
-    ((t == TBASE) ? [ l, v ] : [ l, v, t ]).pack('U*') + target[1..-1]
-  end
-
-  def self.hangul_comp_one(string)
-    length = string.length
-    if length > 1 and 0 <= (lead = string[0].ord - LBASE) and lead < LCOUNT and
-       0 <= (vowel = string[1].ord - VBASE) and vowel < VCOUNT
-      lead_vowel = SBASE + (((lead * VCOUNT) + vowel) * TCOUNT)
-      if length > 2 and 0 <= (trail = string[2].ord - TBASE) and trail < TCOUNT
-        (lead_vowel + trail).chr(Encoding::UTF_8) + string[3..-1]
-      else
-        lead_vowel.chr(Encoding::UTF_8) + string[2..-1]
-      end
-    else
-      string
-    end
-  end
-
-  ## Canonical Ordering
-  def self.canonical_ordering_one(string)
-    sorting = string.each_char.collect { |c| [ c, CLASS_TABLE[c] ] }
-    (sorting.length - 2).downto(0) do |i| # almost, but not exactly bubble sort
-      (0..i).each do |j|
-        later_class = sorting[j + 1].last
-        sorting[j], sorting[j + 1] = sorting[j + 1], sorting[j] if 0 < later_class and later_class < sorting[j].last
-      end
-    end
-    sorting.collect(&:first).join('')
-  end
-
-  ## Normalization Forms for Patterns (not whole Strings)
-  def self.nfd_one(string)
-    string = string.chars.map { |c| DECOMPOSITION_TABLE[c] || c }.join('')
-    canonical_ordering_one(hangul_decomp_one(string))
-  end
-
-  def self.nfc_one(string)
-    nfd_string = nfd_one string
-    start = nfd_string[0]
-    last_class = CLASS_TABLE[start] - 1
-    accents = ''
-    nfd_string[1..-1].each_char do |accent|
-      accent_class = CLASS_TABLE[accent]
-      if last_class < accent_class and composite = COMPOSITION_TABLE[start + accent]
-        start = composite
-      else
-        accents << accent
-        last_class = accent_class
-      end
-    end
-    hangul_comp_one(start + accents)
-  end
-
-  def self.normalize(string, form = :nfc)
-    encoding = string.encoding
-    case encoding
-    when Encoding::UTF_8
-      case form
-      when :nfc
-        string.gsub REGEXP_C, NF_HASH_C
-      when :nfd
-        string.gsub REGEXP_D, NF_HASH_D
-      when :nfkc
-        string.gsub(REGEXP_K, KOMPATIBLE_TABLE).gsub(REGEXP_C, NF_HASH_C)
-      when :nfkd
-        string.gsub(REGEXP_K, KOMPATIBLE_TABLE).gsub(REGEXP_D, NF_HASH_D)
-      else
-        raise ArgumentError, "Invalid normalization form #{form}."
-      end
-    when Encoding::US_ASCII
-      string
-    when *UNICODE_ENCODINGS
-      normalize(string.encode(Encoding::UTF_8), form).encode(encoding)
-    else
-      raise Encoding::CompatibilityError, "Unicode Normalization not appropriate for #{encoding}"
-    end
-  end
-
-  def self.normalized?(string, form = :nfc)
-    encoding = string.encoding
-    case encoding
-    when Encoding::UTF_8
-      case form
-      when :nfc
-        string.scan REGEXP_C do |match|
-          return false  if NF_HASH_C[match] != match
-        end
-        true
-      when :nfd
-        string.scan REGEXP_D do |match|
-          return false  if NF_HASH_D[match] != match
-        end
-        true
-      when :nfkc
-        normalized?(string, :nfc) and string !~ REGEXP_K
-      when :nfkd
-        normalized?(string, :nfd) and string !~ REGEXP_K
-      else
-        raise ArgumentError, "Invalid normalization form #{form}."
-      end
-    when Encoding::US_ASCII
-      true
-    when *UNICODE_ENCODINGS
-      normalized? string.encode(Encoding::UTF_8), form
-    else
-      raise Encoding::CompatibilityError, "Unicode Normalization not appropriate for #{encoding}"
-    end
-  end
-end # module