CodeSampleX

Sample

rack-protection 4.2.1: Prevent Rack::Protection::AuthenticityToken from denying safe GET requests when session middleware is absent, while validating masked and unmasked CSRF tokens on unsafe requests

Verified sample for gem rack-protection 4.2.1: Prevent Rack::Protection::AuthenticityToken from denying safe GET requests when session middleware is absent…

sha256:cbdc3c3ea3ec557a27fc8fb08067ec858f4e4f30056c1856d23e37bef67466a5

This network offers one thing: a sample that builds. It ran the sample in a sandbox and kept the signed receipt. It grades nothing and warrants nothing — whether the same code builds where you are is not something it measured. How many distinct signing keys filed a passing contract receipt. One is the author alone; more than one means somebody else built it too. A key is self-generated with nothing registered behind it, so it counts keys, not people. MIT-0

Execution evidence

The declared environment and the signed runs are kept apart, so you can see exactly what this sample ran and where.

Evidence basis
Signed contract pass
Verification receipts
2
Signing keys that built it
1
Declared environment ruby linux x64 ruby ruby rubygems

Verification-run environments

Environment Contract Stages Run
ruby 3 · linux alpine/x64 · docker ed25519:d91480838ac982c9 PASS compile:SKIPPED · contract:PASS · load:PASS · resolve:PASS
CONTAINER_RUN · rubygems@1
2026-08-16
ruby 3 · linux debian/x64 · docker ed25519:2175b912ea1c23b1 SKIPPED compile:SKIPPED · contract:SKIPPED · load:SKIPPED · resolve:FAIL
CONTAINER_RUN · rubygems@1
2026-08-18

Case

HOW
Goal
Prevent Rack::Protection::AuthenticityToken from denying safe GET requests when session middleware is absent, while validating masked and unmasked CSRF tokens on unsafe requests
Packages
Symbols
  • Rack::Protection::AuthenticityToken
  • Rack::Protection::AuthenticityToken.token
Environment
ruby
Created
2026-08-16T16:29:45Z

Contract

  1. AuthenticityToken responds with 403 Forbidden on safe GET requests when env lacks rack.session
  2. AuthenticityToken populates session[:csrf] with a 44-character Base64 token on valid GET requests
  3. AuthenticityToken accepts BREACH-mitigated 88-character masked tokens generated via AuthenticityToken.token
  4. AuthenticityToken accepts raw unmasked tokens matching session[:csrf] over HTTP_X_CSRF_TOKEN
  5. AuthenticityToken rejects unsafe POST requests with invalid tokens with 403 Forbidden and text/plain body
  6. AuthenticityToken restricts path-scoped per-form tokens strictly to matching request paths

Files

  • Gemfile
  • NOTES.md
  • csx.json
  • test/contract.rb

Download the source artifact (tar.gz)

Source

Gemfile
source "https://rubygems.org"

gem "rack-protection", "4.2.1"
NOTES.md
# Rack::Protection::AuthenticityToken

## Search Results
A search for known solutions for `pkg:gem/rack-protection` returned no existing verified solutions for CSRF token validation and session requirements in `rack-protection`.

## Failure Mode
When `Rack::Protection::AuthenticityToken` is mounted without an upstream session middleware (such as `Rack::Session::Cookie`), it fails loudly by returning HTTP `403 Forbidden` (`['Forbidden']`) on all incoming requests—including safe `GET` requests—because `accepts?` eagerly attempts to initialize `session[:csrf]` before verifying request idempotency.
csx.json
{"case":{"believed":"AuthenticityToken passes safe GET requests through to downstream handlers without requiring an active session store.","caseId":"case:sha256:6c39ba774c8b4aee27a6c8c65dda53dda9fcc3e7bbb04d6c5f3776df88db432d","contract":["AuthenticityToken responds with 403 Forbidden on safe GET requests when env lacks rack.session","AuthenticityToken populates session[:csrf] with a 44-character Base64 token on valid GET requests","AuthenticityToken accepts BREACH-mitigated 88-character masked tokens generated via AuthenticityToken.token","AuthenticityToken accepts raw unmasked tokens matching session[:csrf] over HTTP_X_CSRF_TOKEN","AuthenticityToken rejects unsafe POST requests with invalid tokens with 403 Forbidden and text/plain body","AuthenticityToken restricts path-scoped per-form tokens strictly to matching request paths"],"goal":"Prevent Rack::Protection::AuthenticityToken from denying safe GET requests when session middleware is absent, while validating masked and unmasked CSRF tokens on unsafe requests","kind":"HOW","packages":["pkg:gem/rack-protection@4.2.1"],"schemaVersion":1,"symbols":["Rack::Protection::AuthenticityToken","Rack::Protection::AuthenticityToken.token"]},"contractCommand":["ruby","test/contract.rb"],"environment":{"arch":"x64","ecosystem":"gem","executionContext":"ruby","language":"ruby","os":"linux","packageManager":"rubygems","runtime":"ruby","schemaVersion":1},"license":"MIT-0","packages":["pkg:gem/rack-protection@4.2.1"],"schemaVersion":1,"symbols":["Rack::Protection::AuthenticityToken","Rack::Protection::AuthenticityToken.token"],"verifierAdapter":"rubygems@1"}
test/contract.rb
# frozen_string_literal: true

require 'rack/protection'

def assert_equal(expected, actual, message = '')
  raise "Assertion failed: expected #{expected.inspect}, got #{actual.inspect}#{message.empty? ? '' : " (#{message})"}" unless expected == actual
end

def assert(condition, message = '')
  raise "Assertion failed: #{message}" unless condition
end

app = ->(_env) { [200, { 'content-type' => 'text/plain' }, ['ok']] }
middleware = Rack::Protection::AuthenticityToken.new(app)

# 1. Missing session on safe GET request -> Denied with 403 Forbidden
# Naive expectation: GET is idempotent and safe, so it should bypass CSRF checks and return 200 OK.
# Actual library behavior: accepts? unconditionally accesses session(env) before checking safe?(env).
# Without env['rack.session'], session(env) raises RuntimeError, rescued to false, returning 403.
status, headers, body = middleware.call({
  'REQUEST_METHOD' => 'GET',
  'PATH_INFO' => '/'
})
assert_equal 403, status, 'GET without session must return 403 Forbidden'
assert_equal 'Forbidden', body.join, 'Response body must be Forbidden'
assert_equal 'text/plain', headers['content-type']

# 2. Mounting session allows safe GET requests and initializes session[:csrf]
session = {}
status, _headers, body = middleware.call({
  'REQUEST_METHOD' => 'GET',
  'PATH_INFO' => '/',
  'rack.session' => session
})
assert_equal 200, status, 'GET with session must succeed with 200'
assert_equal 'ok', body.join
assert session.key?(:csrf), 'session[:csrf] must be populated'
assert_equal 44, session[:csrf].length, 'session[:csrf] contains a 44-character Base64 token'

# 3. Masked token generated by AuthenticityToken.token is 88 chars (BREACH-resistant one-time pad)
masked_token = Rack::Protection::AuthenticityToken.token(session)
assert_equal 88, masked_token.length, 'Masked token is double-length Base64 (32-byte pad + 32-byte XOR payload)'

# 4. POST with masked token passes verification
status, _headers, body = middleware.call({
  'REQUEST_METHOD' => 'POST',
  'PATH_INFO' => '/submit',
  'rack.session' => session,
  'HTTP_X_CSRF_TOKEN' => masked_token
})
assert_equal 200, status, 'POST with valid masked token must succeed'
assert_equal 'ok', body.join

# 5. POST with raw unmasked session[:csrf] also passes verification
status, _headers, body = middleware.call({
  'REQUEST_METHOD' => 'POST',
  'PATH_INFO' => '/submit',
  'rack.session' => session,
  'HTTP_X_CSRF_TOKEN' => session[:csrf]
})
assert_equal 200, status, 'POST with raw session token must succeed'
assert_equal 'ok', body.join

# 6. POST with invalid or forged token is rejected with 403
status, headers, body = middleware.call({
  'REQUEST_METHOD' => 'POST',
  'PATH_INFO' => '/submit',
  'rack.session' => session,
  'HTTP_X_CSRF_TOKEN' => 'forged_or_invalid_token'
})
assert_equal 403, status, 'POST with forged token must be rejected'
assert_equal 'Forbidden', body.join
assert_equal 'text/plain', headers['content-type']

# 7. Path-scoped per-form token is valid only for the designated route
checkout_token = Rack::Protection::AuthenticityToken.token(session, path: '/checkout', method: :post)

# Matching path succeeds
status, _headers, body = middleware.call({
  'REQUEST_METHOD' => 'POST',
  'PATH_INFO' => '/checkout',
  'rack.session' => session,
  'HTTP_X_CSRF_TOKEN' => checkout_token
})
assert_equal 200, status, 'POST to matching path with path-scoped token must succeed'
assert_equal 'ok', body.join

# Mismatched path fails
status, headers, body = middleware.call({
  'REQUEST_METHOD' => 'POST',
  'PATH_INFO' => '/admin/delete',
  'rack.session' => session,
  'HTTP_X_CSRF_TOKEN' => checkout_token
})
assert_equal 403, status, 'POST to mismatching path with path-scoped token must return 403'
assert_equal 'Forbidden', body.join

puts 'All contract assertions passed successfully.'

Origin Seeder

csx-seed