omniauth-line-oidc 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f26151039d5a4335bc74e131925ce65064ab85e8d82597d1944bad71c22b283
-  data.tar.gz: bb091bb1368f5efbfceb229914c646b89a2945cb7441f7be00c7815c1efa1490
+  metadata.gz: 14c42cbc3567835fdb73ea96e8cbb4eedc9018e1a672a241b0783f6822291e13
+  data.tar.gz: 54c822e3f40c853af72d947d1b3af03fc08508499dc8461343b6722547916126
 SHA512:
-  metadata.gz: 3e63eee133d0243a9369dc39883a7ea09e8aa6eccaac857c03a4c15215bb9863c1ab62f08e0e72f3de60098969ae79f329409c7996d33771a953ed84fa2b24be
-  data.tar.gz: bdb9da23b3657c86127991e2e81acd67a301bd006aa2bbda12e2639937a216ede80919351afe3ef3e1f0c5dd305fafc0b8af339b8c47770e2efd76267d06a5a2
+  metadata.gz: bf59ff6faa46a241b517ba0ef8dd3c2be2c1bb3fdb98502e80935fdc8de8c065ff972fc5722573ac95f1b589aaadeff638306a7550f0d5b3ecc68fb79ee41493
+  data.tar.gz: cdf79415a87c1121b56a8486efeea7823d69002351615224c7d9ac899e21e8e60fa0832e817bdcb17f3d1a0291d2035db8c5765dcd53ad707d4eb79f4472f8dc

data/CHANGELOG.md

@@ -6,6 +6,25 @@ All notable changes to this gem are recorded here. The format follows
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-11-12
+
+1.0.0 could overflow a 4 KB cookie session: with its defaults, five
+unfinished sign-ins raised `ActionDispatch::Cookies::CookieOverflow` in a
+Rails app.
+
+### Changed
+
+- PKCE is off unless `pkce: true` is set. `omniauth-oauth2` keeps a
+  128-character verifier in the session for each of the last five
+  sign-ins, more than a cookie session has room for. Turn it on when
+  sessions are stored on the server.
+- The nonce no longer takes session space per sign-in. The session holds
+  one secret and an eight-character fingerprint of each sign-in under
+  way, about 110 bytes in all; a sign-in's nonce is derived from the
+  secret and its `state`. The session key is `omniauth.line`
+  (`omniauth.line.nonces` in 1.0.0). A sign-in in flight across the
+  upgrade is verified without a nonce.
+
 ## [1.0.0] - 2026-11-12
 
 First release under the name `omniauth-line-oidc`. The gem continues the

data/README.md

@@ -24,12 +24,8 @@ Replace the gem in your Gemfile; the provider name, the callback path
 (`/auth/line/callback`) and the auth hash keys are the same. Things to
 check:
 
-- PKCE is on by default. It needs nothing from you unless your callback is
-  handled without the session that started the sign-in; see
-  [Callbacks handled by another session](#callbacks-handled-by-another-session).
-- A sign-in started before the deploy and finished after it has no PKCE
-  verifier or nonce in its session, and may be refused by LINE; the user
-  signs in again.
+- A sign-in started before the deploy and finished after it has no nonce
+  in its session; its ID token is verified without one.
 - A sign-in now fails when LINE rejects the ID token. `omniauth-line`
   ignored the rejection and returned no email.
 - `extra` now also carries `raw_info`, and `id_token_claims` when the ID
@@ -87,7 +83,7 @@ provider :line, ENV['LINE_CHANNEL_ID'], ENV['LINE_CHANNEL_SECRET'],
 | Option | Default | Meaning |
 |---|---|---|
 | `scope` | `'profile openid'` | Add `email` once the channel has the permission |
-| `pkce` | `true` | Send a PKCE challenge (`S256`, the only method LINE accepts) |
+| `pkce` | `false` | Send a PKCE challenge (`S256`, the only method LINE accepts). See [Session size and PKCE](#session-size-and-pkce) before turning it on |
 | `redirect_uri` | built from the request | The callback URL registered with LINE. `callback_url`, the name `omniauth-line` used, is accepted too |
 | `verify_options` | `{ open_timeout: 5, read_timeout: 10 }` | Timeouts for the ID token verify call, in seconds |
 
@@ -101,8 +97,8 @@ token the sign-in was just issued. The ID token adds what the profile
 API does not have, the email above all.
 
 - The strategy sends a `nonce` with every authorization request that
-  asks for an ID token, and keeps it in the session under the request's
-  `state`.
+  asks for an ID token. The nonce is derived from the request's `state`
+  and a secret kept in the session, so each sign-in has its own.
 - On the callback it sends the ID token, the channel ID and that nonce
   to LINE's [verify endpoint](https://developers.line.biz/en/reference/line-login/#verify-id-token).
   LINE checks the signature, issuer, audience, expiry and nonce.
@@ -120,22 +116,40 @@ The raw `extra[:id_token]` is passed through as LINE issued it. Do not
 read claims out of it yourself; use `extra[:id_token_claims]`, which is
 only present after verification.
 
-The strategy keeps one nonce for each sign-in a browser session has
-under way, up to five, next to what `omniauth-oauth2` stores for state
-and PKCE. Five unfinished sign-ins come to about 2.5 KB of session data,
-which matters if your sessions live in a 4 KB cookie that is already
-well filled.
+### Session size and PKCE
+
+Sessions are often a 4 KB cookie (Rails' default), and a user who starts
+a sign-in and never returns leaves what it stored behind, up to the five
+most recent.
+
+- For the nonce the strategy keeps one secret and an eight-character
+  fingerprint per sign-in under way: about 110 bytes of session data in
+  all, however many there are.
+- `omniauth-oauth2` keeps the state and redirect URI of each sign-in,
+  and `omniauth` its origin and params. Set `origin_param: false` on the
+  provider unless you read `omniauth.origin`: the origin is the page the
+  sign-in started from, stored once per sign-in.
+- With `pkce: true`, `omniauth-oauth2` also keeps a 128-character
+  verifier per sign-in. In a Rails app with cookie sessions, five
+  unfinished sign-ins with PKCE overflowed the cookie
+  (`ActionDispatch::Cookies::CookieOverflow`). That is why PKCE is off
+  unless you ask for it; turn it on when your sessions are stored on the
+  server.
+
+Without PKCE a sign-in is still tied to the session by `state` and to
+the ID token by the nonce, and the token exchange is authenticated with
+the channel secret.
 
 ### Callbacks handled by another session
 
-The nonce and the PKCE verifier live in the session that started the
+The nonce's secret, like `state`, lives in the session that started the
 sign-in. If your callback arrives in a different session (for example a
 front end on another domain relays it to your API), the strategy cannot
-find them:
+find it:
 
-- Set `pkce: false`, or the token exchange is sent without a verifier
-  and LINE rejects it.
-- The ID token is then verified without a nonce. Everything else about
+- Leave `pkce` off: there would be no verifier to send, and LINE would
+  reject the token exchange.
+- The ID token is verified without a nonce. Everything else about
   it is still checked.
 - You will also need `provider_ignores_state: true`, which gives up the
   CSRF protection `state` provides. Prefer carrying the session across

data/lib/omniauth/line_oidc/version.rb

@@ -2,6 +2,6 @@
 
 module OmniAuth
   module LineOidc
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

data/lib/omniauth/strategies/line.rb

@@ -19,10 +19,10 @@ module OmniAuth
     # claims.
     class Line < OmniAuth::Strategies::OAuth2
       VERIFY_URL = 'https://api.line.me/oauth2/v2.1/verify'
-      NONCE_SESSION_KEY = 'omniauth.line.nonces'
+      SESSION_KEY = 'omniauth.line'
       # Sign-ins a browser session can have under way at once, each with its
       # own nonce; the oldest is dropped beyond this.
-      MAX_STORED_NONCES = 5
+      MAX_PENDING_SIGN_INS = 5
 
       # Failures that say nothing about the token: LINE was not reached, or
       # did not answer.
@@ -33,10 +33,11 @@ module OmniAuth
       option :name, 'line'
       option :scope, 'profile openid'
 
-      # LINE supports PKCE with S256 only, which is what omniauth-oauth2 sends.
-      # Set `pkce: false` when the callback is handled without the session
-      # that started the sign-in, since the verifier lives in that session.
-      option :pkce, true
+      # LINE supports PKCE with S256 only, which is what omniauth-oauth2 sends
+      # with `pkce: true`. It is off unless asked for because omniauth-oauth2
+      # keeps a 128-character verifier in the session for each of the last
+      # five sign-ins, which a 4 KB cookie session has no room for.
+      option :pkce, false
 
       # omniauth-oauth2 only forwards options named here to the authorize
       # URL; anything else set on the strategy is silently dropped. `nonce` is
@@ -91,8 +92,7 @@ module OmniAuth
         super.tap do |params|
           next unless openid_scope?(params[:scope])
 
-          params[:nonce] = SecureRandom.hex(16)
-          remember_nonce(params[:state], params[:nonce])
+          params[:nonce] = issue_nonce(params[:state].to_s)
         end
       end
 
@@ -200,27 +200,50 @@ module OmniAuth
         nil
       end
 
-      # Nonces are kept per `state`, so two sign-ins started in one browser
-      # session each verify against their own.
-      def remember_nonce(state, nonce)
-        nonces = stored_nonces
-        nonces.delete(state.to_s)
-        nonces[state.to_s] = nonce.to_s
-        session[NONCE_SESSION_KEY] = nonces.to_a.last(MAX_STORED_NONCES).to_h
+      # The session is often a 4 KB cookie, so it holds one secret and a short
+      # fingerprint of each sign-in under way rather than a nonce per sign-in.
+      # A sign-in's nonce is derived from the secret and its `state`, which
+      # gives two sign-ins started in one browser session each their own.
+      def issue_nonce(state)
+        secret = stored_secret || SecureRandom.hex(16)
+        pending = (stored_pending - [fingerprint(secret, state)]) << fingerprint(secret, state)
+        session[SESSION_KEY] = { 'secret' => secret, 'pending' => pending.last(MAX_PENDING_SIGN_INS) }
+        nonce_for(secret, state)
       end
 
       # nil when this callback's session did not start the sign-in; the
       # verify call then checks everything about the token except the nonce.
       def take_nonce
-        nonces = stored_nonces
-        nonce = nonces.delete(request.params['state'].to_s)
-        session[NONCE_SESSION_KEY] = nonces if nonce
-        nonce
+        secret = stored_secret
+        state = request.params['state'].to_s
+        pending = stored_pending
+        return unless secret && pending.delete(fingerprint(secret, state))
+
+        session[SESSION_KEY] = { 'secret' => secret, 'pending' => pending }
+        nonce_for(secret, state)
+      end
+
+      def nonce_for(secret, state)
+        OpenSSL::HMAC.hexdigest('SHA256', secret, "nonce:#{state}")[0, 32]
+      end
+
+      def fingerprint(secret, state)
+        OpenSSL::HMAC.hexdigest('SHA256', secret, "state:#{state}")[0, 8]
+      end
+
+      def stored_secret
+        secret = stored['secret']
+        secret if secret.is_a?(String) && !secret.empty?
+      end
+
+      def stored_pending
+        pending = stored['pending']
+        pending.is_a?(Array) ? pending.dup : []
       end
 
-      def stored_nonces
-        nonces = session[NONCE_SESSION_KEY]
-        nonces.is_a?(Hash) ? nonces.dup : {}
+      def stored
+        value = session[SESSION_KEY]
+        value.is_a?(Hash) ? value : {}
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omniauth-line-oidc
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - kazasiki