closeyourit-ruby 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7fb813ea37f0fb206ed31a5a960f795e364c6b23902d59b9b5d6e56ff4fb295
-  data.tar.gz: 926f4e714781796b43ad8c9eaf0e6bf52d7976599a188d3e3720637df623d2bb
+  metadata.gz: a1d5e126aa96c17501b6830b9c7763979c239cd4bf4b0e0d43685b0652025378
+  data.tar.gz: c2d52c988da1288a5cea2986261481ec87fd67db8f3fb0921e2161c90653022e
 SHA512:
-  metadata.gz: d8d590e358c098c3061383a85f9e1593b0b574a0ee52fcb67bbdd76e215cf44076703d9a1917d52acc99e43dee0ba58113afd9516c44b1adaa807341c22cf3ee
-  data.tar.gz: e492934a7b0329fe0ba887dc45b05fa8c148ac3fb9665d866f95bdfe25b1cd114aa66bf95bca76cb83f3f16a96a34b4b24165152a247971e43888358e69291f9
+  metadata.gz: e9b3c6b9d352ad92055e710951157956c6fa3a75c8cbcee6bf6f9dbdbd3eb829ac6c990f54a38a72ef141c2e8d5a71eb714905355cbeee7be94a3957d6f6b22e
+  data.tar.gz: 6bc37b84e2d6a19e6690df0c40732df11fcf32069f1c9942f2d2ddbf6bb76cedb29a94e86c6fd4269002c9f0f9a4c352c53e1c0b41da9a32f5588503ad645b45

data/README.md

@@ -92,7 +92,7 @@ end
 | `send_pii` | `false` | Master switch PII |
 | `obfuscate_sql` | `true` | Maschera i literal nello SQL |
 | `filter_parameters` | `[]` | Chiavi extra da redarre (mergiate con quelle di Rails) |
-| `scrub_message_patterns` | `[]` | Regexp da redarre da messaggi d'eccezione **e da `message` dei log** |
+| `scrub_message_patterns` | `[]` | Regexp **aggiuntive** da redarre da messaggi d'eccezione **e da `message` dei log**; le credenziali `Bearer`/`Basic`/`Token` sono già redatte di serie |
 | `logs_enabled` | `true` | Master switch dello stream di log strutturato |
 | `logs_min_level` | `:info` | Soglia minima: i log sotto (es. `debug`) non vengono inviati |
 | `logs_sample_rate` | `1.0` | Frazione di log inviata (`1.0` tutto, `0.0` niente) |
@@ -381,8 +381,10 @@ Privacy-by-default (`send_pii = false`). In sintesi:
 - **SQL**: inviato il template, **mai** i bind values; `obfuscate_sql` maschera anche i literal inline.
 - **Chiavi sensibili** (`password`, `token`, `authorization`, `cookie`, `secret`, `api_key`, `csrf`,
   `credit_card`, `cvv`, `ssn`, `iban`, …) → `[FILTERED]`; estendibili con `filter_parameters`.
-- **Messaggi d'eccezione**: inviati per il debug, ma redigibili con `scrub_message_patterns` /
-  `before_send`.
+- **Messaggi d'eccezione**: inviati per il debug. Le credenziali di autenticazione finite nel testo
+  (`Authorization: Bearer …`, `Basic …`, `Token …`) sono redatte **di serie**, senza configurazione:
+  chiave e schema restano leggibili, sparisce il valore → `Authorization: Bearer [FILTERED]`. Il resto
+  è redigibile con `scrub_message_patterns` / `before_send`.
 - **Mai inviati**: variabili locali dei frame, argomenti dei metodi, IP/cookie/Authorization, token (che
   viaggia solo nell'header su HTTPS).
 

data/lib/closeyourit/scrubber.rb

@@ -23,6 +23,53 @@ module CloseYourIt
       email phone telephone mobile dob birth passport bearer session pin pan
     ].freeze
 
+    # CYRB-23 — redazione INTEGRATA delle credenziali di autenticazione nel testo libero.
+    # `filter_params`/`filter_value` coprono gli header STRUTTURATI (la chiave `authorization` è in
+    # DENYLIST); un `Authorization: Bearer <token>` incollato dentro `exception.message` o dentro la
+    # riga di un log è testo, non una chiave, e prima di questo ticket partiva in chiaro perché
+    # `scrub_message` applicava solo i pattern configurati dall'utente (default `[]`).
+    #
+    # Forma del testo redatto (decisa qui una volta per tutti gli SDK — gemelli CYDA-26/CYJS-38/
+    # CYPY-15): chiave e schema restano leggibili, sparisce SOLO la credenziale →
+    # `Authorization: Bearer [FILTERED]`. Il messaggio resta diagnosticamente utile (si vede CHE
+    # c'era un header e con quale schema) senza trasportare il segreto.
+    AUTH_SCHEME = /(?i:Bearer|Basic|Token)/
+
+    # `token68` (RFC 7235) con padding `=` finale: la forma di una credenziale reale. Minimo 4
+    # caratteri — un `Basic` di credenziali brevi è corto (`dTpw` = `u:p`); a filtrare la prosa
+    # pensa NOT_PROSE, non la lunghezza.
+    CREDENTIAL_TOKEN = %r{[A-Za-z0-9\-._~+/]{4,}={0,2}}
+
+    # Guardia anti-falso-positivo per lo schema NUDO: quello che segue NON è una credenziale se ha
+    # la forma di una parola scritta da un umano, cioè sole lettere in UNA di tre forme —
+    # `minuscole`, `Capitalizzata`, `MAIUSCOLE` — e più corta di 20 caratteri. Salva "the bearer of
+    # bad news", "invalid bearer credentials", "Basic HTTP authentication", "Bearer Token expired".
+    # Tutto il resto è credenziale: entropia (cifre, `_`, `-`, `.`), maiuscole interne miste
+    # (`dTpw`, base64) o lunghezza ≥ 20 (nessuna parola è così lunga, mentre un token opaco di sole
+    # minuscole sì).
+    # Trade-off accettato: un CamelCase subito dopo lo schema (`Token MyAppName`) viene redatto.
+    PROSE_WORD = /(?:[a-z]{1,19}|[A-Z][a-z]{0,18}|[A-Z]{1,19})/
+    NOT_PROSE = %r{(?!\[FILTERED\])(?!#{PROSE_WORD}(?![A-Za-z0-9\-._~+/=]))}
+
+    # Valore di un header incollato nel testo: sequenza di pezzi non delimitatori, dove una stringa
+    # fra virgolette conta come UN pezzo. NON `\S+`, che si mangerebbe la `)` di
+    # "(Authorization: Bearer <token>)"; ma nemmeno una classe secca, che si fermerebbe alla prima
+    # virgoletta lasciando in chiaro il segreto di `Token token="<token>"` (sintassi RFC 7235 e
+    # `authenticate_with_http_token` di Rails) e di un frammento JSON incollato nel messaggio.
+    QUOTED = /"[^"\n]*"|'[^'\n]*'/
+    HEADER_VALUE = /(?:#{QUOTED}|[^\s,;)\]}"'<>])+/
+
+    # `Authorization:`/`authorization=` (anche `Proxy-Authorization`, anche `authorization_header`)
+    # seguito dal valore: qui la chiave è esplicita, quindi si redige senza euristica di prosa —
+    # over-redaction voluta, coerente con la DENYLIST. `[ \t]` e non `\s`: mai oltre il newline.
+    # Il lookahead copre lo schema OPZIONALE: senza, su un testo già redatto il motore farebbe
+    # backtracking sul ramo "senza schema" e redigerebbe la parola `Bearer` stessa (non idempotente).
+    AUTH_HEADER = /((?i:(?:proxy[_-]?)?authorization)[\w-]*["']?[ \t]*[:=][ \t]*)(?!(?:#{AUTH_SCHEME}[ \t]+)?\[FILTERED\])(#{AUTH_SCHEME}[ \t]+)?#{HEADER_VALUE}/
+
+    # Schema nudo (`Bearer <token>` senza il nome dell'header) seguito da qualcosa che ha la forma
+    # di una credenziale: qui la guardia di prosa serve, la parola "bearer" ricorre nei messaggi.
+    AUTH_CREDENTIAL = /(\b#{AUTH_SCHEME}[ \t]+)#{NOT_PROSE}#{CREDENTIAL_TOKEN}/
+
     STRING_LITERAL = /'(?:[^']|'')*'/
     NUMERIC_LITERAL = /\b\d+(?:\.\d+)?\b/
 
@@ -51,10 +98,16 @@ module CloseYourIt
       sql.to_s.gsub(STRING_LITERAL, "?").gsub(NUMERIC_LITERAL, "?")
     end
 
+    # Regola integrata (schemi di autenticazione) PRIMA dei pattern utente: le due protezioni si
+    # sommano, la prima non è disattivabile — privacy-by-default (CYRB-23).
     def scrub_message(message)
       return message if message.nil?
 
-      @configuration.scrub_message_patterns.reduce(message.to_s) do |acc, pattern|
+      redacted = message.to_s
+                        .gsub(AUTH_HEADER, "\\1\\2#{FILTERED}")
+                        .gsub(AUTH_CREDENTIAL, "\\1#{FILTERED}")
+
+      @configuration.scrub_message_patterns.reduce(redacted) do |acc, pattern|
         acc.gsub(pattern, FILTERED)
       end
     end

data/lib/closeyourit/transport.rb

@@ -91,12 +91,28 @@ module CloseYourIt
       target.relative? ? current + target : target
     end
 
-    # Il Bearer va ri-inviato solo se il redirect resta sullo stesso host (o la sua variante www) e
-    # senza downgrade https→http: evita di consegnare il segreto d'ingest a un host non fidato.
+    # Il Bearer va ri-inviato solo se il redirect resta sull'autorità dell'endpoint configurato:
+    # stesso host (o la sua variante www), stessa porta effettiva e senza downgrade https→http.
+    # La porta fa parte del confine di fiducia (CYRB-22): sullo stesso server una porta diversa è
+    # un servizio distinto, che non deve ricevere il segreto d'ingest.
     def same_authority?(origin, target)
       return false if origin.scheme == "https" && target.scheme != "https"
+      return false unless canonical_host(origin) == canonical_host(target)
 
-      origin.host.to_s.sub(/\Awww\./, "") == target.host.to_s.sub(/\Awww\./, "")
+      origin.port == target.port || canonical_upgrade?(origin, target)
+    end
+
+    # Un endpoint configurato in `http` che redirige a `https` resta fidato: la porta cambia solo
+    # perché cambia lo schema (80 → 443), non perché punti a un servizio su porta non standard.
+    def canonical_upgrade?(origin, target)
+      origin.scheme == "http" && target.scheme == "https" &&
+        origin.port == origin.default_port && target.port == target.default_port
+    end
+
+    # Una porta esplicita pari alla default (`:443` su https) equivale a ometterla: `URI#port` la
+    # normalizza già, qui resta solo da neutralizzare la variante www dell'host canonico.
+    def canonical_host(uri)
+      uri.host.to_s.sub(/\Awww\./, "")
     end
 
     # Estrae " R…: messaggio" dall'envelope d'errore del backend, così il dev vede il codice d'errore

data/lib/closeyourit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloseYourIt
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Alessio Bussolari