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
- 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
Files
- Gemfile
- NOTES.md
- csx.json
- test/contract.rb
Source
source "https://rubygems.org"
gem "rack-protection", "4.2.1"
# 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.
{"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"}
# 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.'