rack-sanitizer 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df0d39073134888976a11608a842c3c5de86b8bde87c8d157b133a99a7278253
-  data.tar.gz: 233aeb1b01a1766196206d2ce51add45b52eb1bea05565716ac46ddca27704e8
+  metadata.gz: fca030fbcd503f8e7a4f61ebd1286552baf24d3b1a8607af3c02ca12dd9533e0
+  data.tar.gz: 44770acabfcea4af68db609520fd158986c72e5a033151352384a08f16174cda
 SHA512:
-  metadata.gz: 378f8675ec6d51e81cdd43b25adbe7ce2bfd02420f0d0da2f953d47d15ebd58bca9373517403d8e6c5e86f4a038e9b41a76519fcf10c26718dbac7185f00b06f
-  data.tar.gz: b108ed7404f5aeed13fc1582d1916fd3d21248c69cde05121225e1adccf2f26c1b3298def5f27a99f601fc665758c164b83fd91eca315674859f81b67db85e4a
+  metadata.gz: 0a88c1f9a8f7aa00cf4b7a6c2ad9306f53218d467177bc154efcb12a9cebf7c2bb79a7404dbd0c1a813929b426a5169d714149488e92318ce4b0b0c80067971e
+  data.tar.gz: 0fc65bc666ac425913aa02abb117545e29dc193961e41a91cf4f704be14567f2271e8e028527a3e0872c2d129029500880959a3058d36eedd3150b079fc4d781

data/.github/workflows/ci.yml

@@ -10,18 +10,22 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["2.5", "2.6", "2.7", "3.0", "3.1", "3.2", "3.3", "3.4", ruby-head, jruby-9.2, jruby-9.3, jruby-head]
-      include:
-        - ruby: "3.4"
-          rubyopt: "--enable-frozen-string-literal --debug-frozen-string-literal"
+        ruby: ["2.5", "2.6", "2.7", "3.0", "3.1", "3.2", "3.3", "3.4", ruby-head, jruby-9.3, jruby-head]
+        rack: ["2.2", "3.0", "3.1", "3.2"]
+        include:
+          - ruby: "3.4"
+            rubyopt: "--enable-frozen-string-literal --debug-frozen-string-literal"
+
+    env:
+      BUNDLE_GEMFILE: gemfiles/rack_${{ matrix.rack }}.gemfile
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
     - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
       with:
         bundler-cache: true # 'bundle install' and cache gems
         ruby-version: ${{ matrix.ruby }}
         bundler: latest
-    - name: Run tests ${{ matrix.rubyopt }}
+    - name: Run tests on Rack ${{ matrix.rack }} ${{ matrix.rubyopt }}
       run: bundle exec rake RUBYOPT="${{ matrix.rubyopt }}"

data/.github/workflows/release.yml

@@ -0,0 +1,24 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  release:
+    permissions:
+      contents: write
+      id-token: write
+
+    environment: release
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
+      with:
+        bundler-cache: true
+        ruby-version: 3.4.4
+    - uses: rubygems/release-gem@7f9650160c1a4e7989fdc9855807bdbd421d8b6b # v1.4.1

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
+/gemfiles/*.lock
 *.rbc
 .bundle
 .config

data/.rubocop.yml

@@ -0,0 +1,12 @@
+
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+AllCops:
+  SuggestExtensions: false
+  TargetRubyVersion: 2.5
+  Exclude:
+    - bin/bacon
+
+Lint/Void:
+  Enabled: false

data/Gemfile

@@ -1,4 +1,10 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rack-sanitizer.gemspec
 gemspec
+
+gem 'rubocop-shopify'
+gem 'rake'
+gem 'ostruct'

data/Gemfile.lock

@@ -1,26 +1,57 @@
 PATH
   remote: .
   specs:
-    rack-sanitizer (2.0.4)
+    rack-sanitizer (2.1.0)
       rack (>= 1.0, < 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    bacon (1.2.0)
-    bacon-colored_output (1.1.1)
-      bacon
-    rack (3.0.10)
+    ast (2.4.3)
+    json (2.21.2)
+    language_server-protocol (3.17.0.6)
+    lint_roller (1.1.0)
+    ostruct (0.6.1)
+    parallel (2.1.0)
+    parser (3.3.12.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    racc (1.8.1)
+    rack (3.1.21)
+    rainbow (3.1.1)
     rake (13.1.0)
+    regexp_parser (2.12.0)
+    rubocop (1.90.0)
+      json (>= 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.50.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-shopify (3.0.2)
+      lint_roller
+      rubocop (~> 1.72, >= 1.72.1)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bacon
-  bacon-colored_output
+  ostruct
   rack-sanitizer!
   rake
+  rubocop-shopify
 
 BUNDLED WITH
    2.5.7

data/LICENSE.txt

@@ -1,3 +1,4 @@
+Copyright (c) 2026 Shopify Inc.
 Copyright (c) 2013 Peter Zotov
 
 MIT License
@@ -19,4 +20,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -44,7 +44,7 @@ The generic sanitization algorithm is as follows:
       1. Force the encoding to ASCII8-BIT.
       2. Re-encode it as UTF-8, replacing invalid and undefined characters as U+FFFD.
 
-For fields with "raw data", the algorithm is applied once and the (UTF-8 encoded) result is left in the environment.
+For fields with "raw data", the algorithm is applied once. ASCII-only results remain UTF-8. Results with non-ASCII characters use ASCII-8BIT encoding to satisfy the Rack environment specification.
 
 For fields with "percent-encoded data", the algorithm is applied twice to catch both invalid characters appearing as-is and invalid characters appearing in the percent encoding. The percent encoded, ASCII-8BIT encoded result is left in the environment.
 

data/Rakefile

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 
-task :default => :spec
+task default: :spec
 
 desc "Run tests"
 task :spec do

data/bin/rubocop

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/dev.yml

@@ -0,0 +1,17 @@
+name: rack-sanitizer
+
+type: ruby
+nix: true
+
+up:
+  - ruby
+  - bundler
+
+commands:
+  test:
+    syntax:
+      argument: file
+      optional: args...
+    run: bundle exec rake spec
+  style:
+    run: bin/rubocop

data/gemfiles/rack_2.2.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+gem "rubocop-shopify"
+gem "rake"
+gem "ostruct"
+gem "rack", "~> 2.2.0"

data/gemfiles/rack_3.0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+gem "rubocop-shopify"
+gem "rake"
+gem "ostruct"
+gem "rack", "~> 3.0.0"

data/gemfiles/rack_3.1.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+gem "rubocop-shopify"
+gem "rake"
+gem "ostruct"
+gem "rack", "~> 3.1.0"

data/gemfiles/rack_3.2.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+gem "rubocop-shopify"
+gem "rake"
+gem "ostruct"
+gem "rack", "~> 3.2.0"

data/lib/rack/sanitizer.rb

@@ -7,9 +7,11 @@ module Rack
   class Sanitizer
     # options[:sanitizable_content_types] Array
     # options[:additional_content_types] Array
-    def initialize(app, options={})
+    def initialize(app, options = {})
       @app = app
-      @strategy = build_strategy(options)
+      strategy = options.fetch(:strategy) { :replace }
+      @strategy = build_strategy(strategy)
+      @exception_strategy = strategy == :exception
       @sanitizable_content_types = options[:sanitizable_content_types]
       @sanitizable_content_types ||= SANITIZABLE_CONTENT_TYPES + (options[:additional_content_types] || [])
     end
@@ -17,25 +19,28 @@ module Rack
     def call(env)
       env = sanitize(env)
       begin
+        if @exception_strategy && env['rack.input'].is_a?(SanitizedRackInput)
+          env['rack.input'].ensure_sanitized
+        end
         @app.call(env)
       rescue SanitizedRackInput::FailedToReadBody
-        return [400, { "Content-Type" => "text/plain" }, ["Bad Request"]]
+        [400, { "content-type" => "text/plain" }, ["Bad Request"]]
       end
     end
 
     DEFAULT_STRATEGIES = {
       replace: lambda do |input|
-        input.
-          force_encoding(Encoding::ASCII_8BIT).
-          encode!(Encoding::UTF_8,
-                  invalid: :replace,
-                  undef:   :replace)
+        input
+          .force_encoding(Encoding::ASCII_8BIT)
+          .encode!(Encoding::UTF_8,
+            invalid: :replace,
+            undef:   :replace)
         input
       end,
       exception: lambda do |input|
-        input.
-          force_encoding(Encoding::ASCII_8BIT).
-          encode!(Encoding::UTF_8)
+        input
+          .force_encoding(Encoding::ASCII_8BIT)
+          .encode!(Encoding::UTF_8)
         input
       end
     }.freeze
@@ -73,8 +78,6 @@ module Rack
             env[key] = sanitize_uri_encoded_string(value)
           end
         elsif key.to_s.start_with?("HTTP_")
-          # Just sanitize the headers and leave them in UTF-8. There is
-          # no reason to have UTF-8 in headers, but if it's valid, let it be.
           if value.frozen?
             env[key] = sanitize_string(value.dup).freeze
           else
@@ -86,9 +89,7 @@ module Rack
 
     private
 
-    def build_strategy(options)
-      strategy = options.fetch(:strategy) { :replace }
-
+    def build_strategy(strategy)
       return strategy unless DEFAULT_STRATEGIES.key?(strategy)
 
       DEFAULT_STRATEGIES[strategy]
@@ -128,7 +129,7 @@ module Rack
       return unless env['HTTP_COOKIE']
 
       env['HTTP_COOKIE'] = env['HTTP_COOKIE']
-        .split(/[;,] */n)
+        .split(/; */n)
         .map { |cookie| sanitize_uri_encoded_string(cookie) }
         .join('; ')
     end
@@ -157,8 +158,8 @@ module Rack
 
       def decode_string(input)
         unescape_unreserved(
-          sanitize_string(input).
-            force_encoding(Encoding::ASCII_8BIT))
+          sanitize_string(input)
+            .force_encoding(Encoding::ASCII_8BIT))
       end
 
       # RFC3986, 2.2 states that the characters from 'reserved' group must be
@@ -202,14 +203,12 @@ module Rack
 
           input.force_encoding(Encoding::UTF_8)
 
-          if input.valid_encoding?
-            input
-          else
-            @strategy.call(input)
-          end
-        else
-          input
+          input = @strategy.call(input) unless input.valid_encoding?
+          # Rack requires non-ASCII strings to use ASCII-8BIT encoding.
+          input = input.b if input.is_a?(String) && !input.ascii_only?
         end
+
+        input
       end
     end
 
@@ -240,6 +239,10 @@ module Rack
         sanitized_io.each(&block)
       end
 
+      def ensure_sanitized
+        sanitized_io
+      end
+
       def rewind
         sanitized_io.rewind
       end

data/rack-sanitizer.gemspec

@@ -1,27 +1,22 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
 Gem::Specification.new do |gem|
   gem.name          = "rack-sanitizer"
-  gem.version       = '2.0.4'
-  gem.authors       = ["Jean Boussier", "whitequark"]
+  gem.version       = '2.1.0'
+  gem.authors       = ["Shopify - Ruby and Rails Infratructure", "Jean Boussier", "whitequark"]
   gem.license       = "MIT"
-  gem.email         = ["jean.boussier@gmail.org"]
+  gem.email         = ["ruby-and-rails-infrastructure@shopify.com"]
   gem.description   = %{Rack::Sanitizer is a Rack middleware which cleans up } +
                       %{invalid UTF8 characters in request URI and headers.}
   gem.summary       = "It is a mordernized and optimized fork of rack-utf8_sanitizer"
   gem.homepage      = "http://github.com/Shopify/rack-sanitizer"
 
   gem.files         = `git ls-files`.split($/)
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
   gem.metadata["allowed_push_host"] = "https://rubygems.org/"
 
   gem.required_ruby_version = '>= 2.5'
 
-  gem.add_dependency             "rack", '>= 1.0', '< 4.0'
-
-  gem.add_development_dependency "bacon"
-  gem.add_development_dependency "bacon-colored_output"
-  gem.add_development_dependency "rake"
+  gem.add_dependency "rack", '>= 1.0', '< 4.0'
 end

data/test/test_sanitizer.rb

@@ -1,26 +1,70 @@
-# encoding:ascii-8bit
+# encoding: ascii-8bit
+# frozen_string_literal: true
 
 require 'cgi'
+require 'rack/lint'
+require 'rack/mock'
 require 'rack/sanitizer'
 
 describe Rack::Sanitizer do
+  class ResponseBody < String
+    attr_reader :env
+
+    def initialize(env)
+      super('')
+      @env = env
+    end
+  end
+
   before do
-    @app = Rack::Sanitizer.new(-> env { env["rack.input"]&.size; env })
+    @build_app = ->(options = {}) do
+      linted_app = Rack::Lint.new(->env { [200, {}, [ResponseBody.new(env)]] })
+      Rack::Sanitizer.new(->env { linted_app.(env) }, options)
+    end
+
+    @rack_env = ->(env) do
+      Rack::MockRequest.env_for('/').tap do |request_env|
+        request_env.delete('CONTENT_LENGTH')
+        request_env.merge!(env.reject { |_key, value| value.nil? })
+      end
+    end
+
+    @call_app = ->(env) do
+      response = @app.(@rack_env.call(env))
+      response_body = nil
+      response[2].each do |chunk|
+        response_body = chunk
+      end
+      response[2].close
+      response_body.env
+    end
+
+    @app = @build_app.call
+  end
+
+  it "conforms to Rack::Lint" do
+    app = Rack::Lint.new(Rack::Sanitizer.new(->(_env) { [200, {}, ["OK"]] }))
+    status, headers, body = app.(Rack::MockRequest.env_for('/'))
+
+    status.should == 200
+    headers.should == {}
+    body.each { |chunk| chunk.should == "OK" }
+    body.close
   end
 
   shared :does_sanitize_plain do
     it "sanitizes plaintext entity (HTTP_USER_AGENT)" do
-      env    = @app.({ "HTTP_USER_AGENT" => @plain_input })
+      env    = @call_app.call({ "HTTP_USER_AGENT" => @plain_input })
       result = env["HTTP_USER_AGENT"]
 
-      result.encoding.should == Encoding::UTF_8
+      result.encoding.should == Encoding::ASCII_8BIT
       result.should.be.valid_encoding
     end
   end
 
   shared :does_sanitize_uri do
     it "sanitizes URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -31,7 +75,7 @@ describe Rack::Sanitizer do
   describe "with invalid host input" do
     it "sanitizes host entity (SERVER_NAME)" do
       host   = "host\xD0".dup.force_encoding(Encoding::UTF_8)
-      env    = @app.({ "SERVER_NAME" => host })
+      env    = @call_app.call({ "SERVER_NAME" => host })
       result = env["SERVER_NAME"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -77,18 +121,18 @@ describe Rack::Sanitizer do
 
   shared :identity_plain do
     it "does not change plaintext entity (HTTP_USER_AGENT)" do
-      env    = @app.({ "HTTP_USER_AGENT" => @plain_input })
+      env    = @call_app.call({ "HTTP_USER_AGENT" => @plain_input })
       result = env["HTTP_USER_AGENT"]
 
-      result.encoding.should == Encoding::UTF_8
+      result.encoding.should == (@plain_input.ascii_only? ? Encoding::UTF_8 : Encoding::ASCII_8BIT)
       result.should.be.valid_encoding
-      result.should == @plain_input
+      result.bytes.should == @plain_input.bytes
     end
   end
 
   shared :identity_uri do
     it "does not change URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -122,7 +166,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not change URI-like entity (REQUEST_PATH)" do
-      env    = @app.({ "REQUEST_PATH" => @uri_input })
+      env    = @call_app.call({ "REQUEST_PATH" => @uri_input })
       result = env["REQUEST_PATH"]
 
       result.encoding.should == Encoding::US_ASCII
@@ -151,13 +195,13 @@ describe Rack::Sanitizer do
 
   describe "with frozen strings" do
     before do
-      @plain_input = "bar baz".freeze
-      @uri_input   = "http://bar/bar+baz".freeze
+      @plain_input = "bar baz"
+      @uri_input   = "http://bar/bar+baz"
     end
 
     it "preserves the frozen? status of input" do
-      env  = @app.({ "HTTP_USER_AGENT" => @plain_input,
-                     "REQUEST_PATH" => @uri_input })
+      env  = @call_app.call({ "HTTP_USER_AGENT" => @plain_input,
+                              "REQUEST_PATH" => @uri_input })
 
       env["HTTP_USER_AGENT"].should.be.frozen
       env["REQUEST_PATH"].should.be.frozen
@@ -170,8 +214,8 @@ describe Rack::Sanitizer do
     end
 
     it "sanitizes REQUEST_PATH with invalid UTF-8 URI input" do
-      env  = @app.({ :requested_at => "2014-07-22",
-                     "REQUEST_PATH" => @uri_input })
+      env = @call_app.call({ "requested_at" => "2014-07-22",
+                             "REQUEST_PATH" => @uri_input })
 
       result = env["REQUEST_PATH"]
 
@@ -193,17 +237,15 @@ describe Rack::Sanitizer do
 
     def sanitize_form_data(request_env = request_env())
       @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
-      @response_env = @app.(request_env)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
 
-      @response_env['rack.input'].rewind
       behaves_like :does_sanitize_plain
       behaves_like :does_sanitize_uri
       behaves_like :identity_plain
       behaves_like :identity_uri
-      @response_env['rack.input'].close
     end
 
     class BrokenIO < StringIO
@@ -213,9 +255,18 @@ describe Rack::Sanitizer do
     end
 
     it "returns HTTP 400 on EOF" do
-      @rack_input = BrokenIO.new
-      @response_env = @app.(request_env)
-      @response_env.should == [400, {"Content-Type"=>"text/plain"}, ["Bad Request"]]
+      @rack_input = BrokenIO.new("".b)
+      app = Rack::Lint.new(Rack::Sanitizer.new(->env {
+        env['rack.input'].read
+        [200, {}, ["OK"]]
+      }))
+      env = @rack_env.call(request_env.merge("HTTP_USER_AGENT" => "foo"))
+      status, headers, body = app.(env)
+      response_body = []
+      body.each { |chunk| response_body << chunk }
+      body.close
+
+      [status, headers, response_body].should == [400, { "content-type" => "text/plain" }, ["Bad Request"]]
     end
 
     it "sanitizes StringIO rack.input" do
@@ -241,7 +292,7 @@ describe Rack::Sanitizer do
     end
 
     it "sanitizes StringIO rack.input with bad encoding" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       sanitize_form_data do |sanitized_input|
@@ -292,7 +343,7 @@ describe Rack::Sanitizer do
 
     it "sanitizes non-StringIO rack.input with bad encoding" do
       require 'rack/rewindable_input'
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = Rack::RewindableInput.new(StringIO.new(input))
 
       sanitize_form_data do |sanitized_input|
@@ -303,7 +354,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize the rack body if there is no CONTENT_TYPE" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => nil)
@@ -315,7 +366,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize the rack body if there is empty CONTENT_TYPE" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => '')
@@ -327,10 +378,10 @@ describe Rack::Sanitizer do
     end
 
     it "adjusts content-length when replacing input" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
-      env = request_env.update("CONTENT_LENGTH" => input.bytesize)
+      env = request_env.update("CONTENT_LENGTH" => input.bytesize.to_s)
       sanitize_form_data(env) do |sanitized_input|
         sanitized_input.bytesize.should != input.bytesize
         @response_env["CONTENT_LENGTH"].should == sanitized_input.bytesize.to_s
@@ -338,7 +389,7 @@ describe Rack::Sanitizer do
     end
 
     it "does not sanitize null bytes by default" do
-      input =  "foo=bla&quux=bar%00"
+      input = "foo=bla&quux=bar%00"
       @rack_input = StringIO.new input
 
       sanitize_form_data do |sanitized_input|
@@ -361,18 +412,24 @@ describe Rack::Sanitizer do
 
     it "sanitizes bad http cookie" do
       @cookie = "foo=bla; quux=bar\xED"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should != @cookie
       response_env['HTTP_COOKIE'].should == 'foo=bla; quux=bar%EF%BF%BD'
     end
 
+    it "preserves commas in http cookie values" do
+      @cookie = "foo=bar,baz; quux=qux"
+      response_env = @call_app.call(request_env)
+      response_env['HTTP_COOKIE'].should == @cookie
+    end
+
     it "does not change ok http cookie" do
       @cookie = "foo=bla; quux=bar"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should == @cookie
 
       @cookie = "foo=b%3bla; quux=b%20a%20r"
-      response_env = @app.(request_env)
+      response_env = @call_app.call(request_env)
       response_env['HTTP_COOKIE'].should == @cookie
     end
   end
@@ -390,14 +447,14 @@ describe Rack::Sanitizer do
 
     def sanitize_data(request_env = request_env())
       @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
-      @response_env = @app.(request_env)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
     end
 
     it "does not sanitize custom content-type by default" do
-      input =  "foo=bla&quux=bar\xED"
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
@@ -409,47 +466,47 @@ describe Rack::Sanitizer do
     end
 
     it "sanitizes custom content-type if additional_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, additional_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(additional_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "sanitizes default content-type if additional_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, additional_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(additional_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => 'application/json')
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "sanitizes custom content-type if sanitizable_content_types given" do
-      @app = Rack::Sanitizer.new(-> env { env }, sanitizable_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(sanitizable_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "does not sanitize default content-type if sanitizable_content_types does not include it" do
-      @app = Rack::Sanitizer.new(-> env { env }, sanitizable_content_types: ["application/vnd.api+json"])
-      input =  "foo=bla&quux=bar\xED"
+      @app = @build_app.call(sanitizable_content_types: ["application/vnd.api+json"])
+      input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env.update('CONTENT_TYPE' => 'application/json')
@@ -474,28 +531,28 @@ describe Rack::Sanitizer do
 
     def sanitize_data(request_env = request_env())
       @uri_input = "http://bar/foo+%2F%3A+bar+%D0%BB%D0%BE%D0%BB".dup.force_encoding(Encoding::UTF_8)
-      @response_env = @app.(request_env)
+      @response_env = @call_app.call(request_env)
       sanitized_input = @response_env['rack.input'].read
 
       yield sanitized_input if block_given?
     end
 
     it "calls a default strategy (replace)" do
-      @app = Rack::Sanitizer.new(-> env { env })
+      @app = @build_app.call
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
 
       env = request_env
       sanitize_data(env) do |sanitized_input|
-        sanitized_input.encoding.should == Encoding::UTF_8
+        sanitized_input.encoding.should == Encoding::ASCII_8BIT
         sanitized_input.should.be.valid_encoding
         sanitized_input.should != input
       end
     end
 
     it "calls the exception strategy" do
-      @app = Rack::Sanitizer.new(-> env { env }, strategy: :exception)
+      @app = @build_app.call(strategy: :exception)
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input
@@ -504,12 +561,36 @@ describe Rack::Sanitizer do
       should.raise(EncodingError) { sanitize_data(env) }
     end
 
+    it "returns HTTP 400 before the application reads invalid rack.input" do
+      input = "{\"user_session\": {\"invalid\": \"\x80\"}}".b
+      @rack_input = StringIO.new(input)
+
+      sanitizer = Rack::Sanitizer.new(->(_env) { [200, {}, ["OK"]] }, strategy: :exception)
+      app = ->(env) do
+        begin
+          sanitizer.call(env)
+        rescue EncodingError
+          [400, {}, ["Bad Request"]]
+        end
+      end
+      app = Rack::Lint.new(app)
+
+      env = @rack_env.call(request_env.merge("HTTP_USER_AGENT" => "foo"))
+      env["CONTENT_LENGTH"] = input.bytesize.to_s
+      status, headers, body = app.(env)
+      response_body = []
+      body.each { |chunk| response_body << chunk }
+      body.close
+
+      [status, headers, response_body].should == [400, {}, ["Bad Request"]]
+    end
+
     it "accepts a proc as a strategy" do
-      truncate = -> (input) do
+      truncate = ->(input) do
         'replace'.dup.force_encoding(Encoding::UTF_8)
       end
 
-      @app = Rack::Sanitizer.new(-> env { env }, strategy: truncate)
+      @app = @build_app.call(strategy: truncate)
 
       input = "foo=bla&quux=bar\xED"
       @rack_input = StringIO.new input

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rack-sanitizer
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.0
 platform: ruby
 authors:
+- Shopify - Ruby and Rails Infratructure
 - Jean Boussier
 - whitequark
 bindir: bin
 cert_chain: []
-date: 2025-03-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -30,52 +31,10 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: bacon
-  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: bacon-colored_output
-  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: 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'
 description: Rack::Sanitizer is a Rack middleware which cleans up invalid UTF8 characters
   in request URI and headers.
 email:
-- jean.boussier@gmail.org
+- ruby-and-rails-infrastructure@shopify.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -84,7 +43,9 @@ files:
 - ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".github/workflows/cla.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
 - Gemfile.lock
@@ -92,6 +53,12 @@ files:
 - README.md
 - Rakefile
 - bin/bacon
+- bin/rubocop
+- dev.yml
+- gemfiles/rack_2.2.gemfile
+- gemfiles/rack_3.0.gemfile
+- gemfiles/rack_3.1.gemfile
+- gemfiles/rack_3.2.gemfile
 - lib/rack/sanitizer.rb
 - rack-sanitizer.gemspec
 - test/test_sanitizer.rb
@@ -114,8 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 4.0.19
 specification_version: 4
 summary: It is a mordernized and optimized fork of rack-utf8_sanitizer
-test_files:
-- test/test_sanitizer.rb
+test_files: []