shugoi 0.4.6 → 0.4.8

data/lib/shugoi/core.rb

@@ -1,107 +1,59 @@
-# frozen_string_literal: true
-
 module Shugoi
-  # Évaluation d'une requête : pre-flight PoW challenge, /__sg_challenge, blocage headless,
-  # cookie __sg_ok, preuve single-use, rate-limit du challenge, protection des assets.
-  # Parité avec core.ts (module Node).
   class Core
-    # Résultat de blocage renvoyé au middleware.
+    attr_reader :bot_policy
+
     Decision = Struct.new(:status, :content_type, :body, :headers, keyword_init: true)
 
     POW_OK_TTL_MS = 30 * 24 * 3600 * 1000
     POW_TTL_MS = 60_000
-    CHALLENGE_LIMIT = 60
-    CHALLENGE_WINDOW_MS = 60_000
-    CHALLENGE_MAX_BLOCK_MS = 15 * 60 * 1000
-    VALIDATION_WARN_INTERVAL = 3_600_000
-
     def initialize(config, pow, api_client, config_cache = nil)
       @config = config
       @pow = pow
       @api_client = api_client
       @config_cache = config_cache
-      @validation_valid = false
-      @validation_failed = false
-      @validation_warned_at = 0
+      @key_validator = KeyValidator.new(config, api_client)
       @used_proofs = {}
-      @challenge_limits = {}
       @mutex = Mutex.new
-      @bot_verifier = config.verify_bots ? BotVerifier.new : nil
+      @challenge_limiter = ChallengeLimiter.new
+      @bot_policy = BotPolicy.new(config)
     end
 
-    # @param ctx [Hash] { path:, ua:, ip:, host:, accept_language:, sec_fetch_dest:, sec_fetch_mode:, sg_proof:, sg_ok:, sg_authorized:, forwarded_prefix: }
-    # @return [Decision, nil] nil = laisser passer
     def evaluate(ctx)
       path = ctx[:path].to_s
 
-      # Protection des assets à contenu (/assets/*.js, *.css) — parité core.ts. Le bundle
-      # SPA est téléchargeable publiquement sans ce verrou : on exige le cookie
-      # __sg_authorized posé par handleRender après un render réussi (grant valide).
-      # NB : vérifié AVANT l'allowlist (les assets sont allowlistés pour le split-render).
       if path.match?(%r{/assets/[^?#]+\.(js|css)(\?|$)})
         auth_ok = !ctx[:sg_authorized].to_s.empty? && @pow.sg_authorized_valid?(ctx[:sg_authorized])
         return Decision.new(status: 403, content_type: "text/plain", body: BLOCK_PAGE, headers: {}) unless auth_ok
       end
 
-      ensure_validated
-      warn_if_validation_failed
-      return nil if @config.is_allowlisted?(path)
+      @key_validator.validate
+      @key_validator.warn_if_failed
+      return nil if @config.allowlisted?(path)
 
-      # Route du challenge JS (le navigateur arrive ici après le 307).
       return challenge_page(ctx) if path == "/__sg_challenge"
 
-      # Pre-flight PoW challenge (anti-curl/view-source).
-      return nil if path.include?("/__shugoi/") || path.start_with?("/api/")
       ua = ctx[:ua].to_s
+      return nil if path.include?("/__shugoi/") || path.start_with?("/api/")
+      preflight = preflight_decision(ctx, ua)
+      return preflight if preflight
 
-      if !@config.signing_secret.to_s.empty?
-        proof = ctx[:sg_proof].to_s
-        valid_proof = !proof.empty? && @pow.valid?(proof)
-        # Re-audit (résidu #3) : un cookie __sg_ok valide (HMAC serveur, 30 j) saute le
-        # pre-flight PoW. Posé APRÈS une première résolution réussie (middleware).
-        valid_cookie = !ctx[:sg_ok].to_s.empty? && @pow.sg_ok_valid?(ctx[:sg_ok], ctx[:ip].to_s, ua)
-        # Round 16 (R2) : la preuve est SINGLE-USE (par IP) — un rejeu → 307.
-        proof_fresh = valid_proof ? consume_proof(proof) : false
-        unless valid_cookie || proof_fresh
-          return pow_challenge_307(ctx) if allow_challenge?(ctx[:ip].to_s)
-
-          loc = Locales.resolve_locale(@config.locale, ctx[:accept_language])
-          msgs = Locales.messages(loc)
-          return Decision.new(status: 429, content_type: "text/html", body: shield_page(msgs[:rate_limit_title], msgs[:rate_limit_body].call("1 min"), msgs[:rate_limit_badge], ctx[:host].to_s, 60, loc), headers: {})
-        end
-      end
-
-      # Flags de détection (whitelist + skipPaths), parité fetchConfigForSiteKey.
       flags = @config_cache ? @config_cache.fetch(@config.site_key)[:flags] : {}
       headless_enabled = flags["enableHeadlessCheck"] != false
 
-      # Rate limit check — activé uniquement si le flag est explicitement vrai.
       if flags["enableRateLimit"] == true
         rl = @api_client.check_rate_limit(@config.site_key, ctx[:ip].to_s, ctx[:ua].to_s)
         if rl && rl["allowed"] == false
           reset_at = rl["resetAt"].to_i
           reset_at = (reset_at / 1000.0).ceil if reset_at > 1_000_000_000_000
           remain = [0, reset_at - Utils.now_sec].max
-          mins = remain / 60
-          secs = remain % 60
-          time_str = if mins.positive?
-                       "#{mins} min#{mins > 1 ? 's' : ''}#{secs.positive? ? " #{secs} s" : ''}"
-                     else
-                       "#{secs} seconde#{secs > 1 ? 's' : ''}"
-                     end
+          time_str = RateLimitFormatter.remaining(remain)
           loc = @config.locale || Locales.resolve_locale(nil, ctx[:accept_language])
           msgs = Locales.messages(loc)
-          body = if @config.block_page.respond_to?(:call)
-                   @config.block_page.call(reason: "rate_limit", title: msgs[:rate_limit_title], message: msgs[:rate_limit_body].call(time_str), badge: msgs[:rate_limit_badge], host: ctx[:host].to_s, remainingSeconds: remain, locale: loc)
-                 else
-                   shield_page(msgs[:rate_limit_title], msgs[:rate_limit_body].call(time_str), msgs[:rate_limit_badge], ctx[:host].to_s, remain, loc)
-                 end
-          return Decision.new(status: 429, content_type: "text/html", body: body, headers: {})
+          return rate_limit_decision(ctx, msgs, loc, remain, time_str)
         end
       end
 
-      # Blocage headless (UA). Actif par défaut, y compris sans configuration chargée.
-      if headless_enabled && !ua.empty? && !is_trusted_bot?(ua, ctx[:ip].to_s) && @config.is_headless?(ua)
+      if headless_enabled && !ua.empty? && !@bot_policy.trusted?(ua, ctx[:ip].to_s) && @config.headless?(ua)
         @api_client.post_event(@config.site_key, "headless", "")
         return Decision.new(status: @config.block_status, content_type: "text/plain", body: BLOCK_PAGE, headers: {})
       end
@@ -109,118 +61,52 @@ module Shugoi
       nil
     end
 
-    # Vrai si un bot whitelisté (UA) est authentifié par DNS inverse (parité isTrustedBot).
-    def is_trusted_bot?(ua, ip)
-      return false unless @config.is_whitelisted_bot?(ua)
-      return true unless @bot_verifier
-
-      verified = @bot_verifier.verify(ua, ip)
-      verified.nil? ? false : verified
-    end
-
-    # Page challenge (tableau en commentaire + JS PoW inline).
     def challenge_page(ctx)
       loc = Locales.resolve_locale(@config.locale, ctx[:accept_language])
-      if !allow_challenge?(ctx[:ip].to_s)
+      unless @challenge_limiter.allow?(ctx[:ip].to_s)
         msgs = Locales.messages(loc)
-        return Decision.new(status: 429, content_type: "text/html", body: shield_page(msgs[:rate_limit_title], msgs[:rate_limit_body].call("1 min"), msgs[:rate_limit_badge], ctx[:host].to_s, 60, loc), headers: {})
+        return rate_limit_decision(ctx, msgs, loc, 60, "1 min")
       end
-      js = <<~JS
-        (function(){
-        var P=new URLSearchParams(location.search);
-        var salt=P.get('salt')||'', ts=P.get('ts')||'', nonce=P.get('nonce')||'', diff=parseInt(P.get('diff')||'#{@config.pow_difficulty}',10), path=P.get('path')||'/';
-        // Open redirect (audit #5) : un //evil.com (protocole-relatif) ou un backslash
-        // détourneraient le location.replace ci-dessous vers un domaine externe.
-        if(path.charAt(0)!=='/'||path.charAt(1)==='/'||path.indexOf('\\\\')>=0)path='/';
-        var enc=new TextEncoder();
-        // Audit 2026-08-03 : comptage de bits CORRIGÉ (zéros internes du premier nibble
-        // non-nul comptés) — DOIT rester synchrone avec Pow#valid? + guard + whitelist.
-        function bits(d){var l=0;for(var i=0;i<d.length;i++){var b=parseInt(d[i],16);if(b===0){l+=4;continue}l+=(b&8)?0:(b&4)?1:(b&2)?2:3;break}return l}
-        var n=0;
-        function step(){
-          crypto.subtle.digest('SHA-256',enc.encode(salt+':'+n.toString(16))).then(function(buf){
-            var h=Array.from(new Uint8Array(buf)).map(function(v){return v.toString(16).padStart(2,'0')}).join('');
-            if(bits(h)>=diff){var base=path;var q=(base.indexOf('?')>=0?'&':'?')+'sg_proof='+ts+':'+nonce+':'+n.toString(16);location.replace(base+q)}
-            else{n++;if(n<300000)step()}
-          }).catch(function(){location.reload()});
-        }
-        step();
-        })();
-      JS
+      js = ChallengeScript.render(@config.pow_difficulty)
       html = "<!--\n#{BLOCK_PAGE}-->\n<script>#{js}</script>"
       Decision.new(status: 200, content_type: "text/html", body: html, headers: {})
     end
 
     private
 
-    # Page de blocage néobrutaliste (parité shieldPage de core.ts).
-    def shield_page(title, msg, badge, host, remain_secs, locale)
-      msgs = Locales.messages(locale)
-      prefix = msg.to_s.sub(/Il reste \d+ seconde?s?.*$/, "").sub(/Retry in \d+s?.*$/, "").strip
-      countdown_script = if remain_secs.positive?
-                           '<script>var s=' + remain_secs.to_s + ';var i=setInterval(function(){s--;var e=document.getElementById("cd");if(e){if(s<=0){e.innerHTML="0s";clearInterval(i);setTimeout(function(){location.reload()},500)}else{e.innerHTML=s+"s"}}},1000)</script>'
-                         else
-                           ""
-                         end
-      desc = remain_secs.positive? ? "#{prefix} #{msgs[:retry_in_seconds].call(remain_secs)}" : msg.to_s
-      html_title = Utils.escape_html(title.to_s.empty? ? msgs[:blocked_title] : title)
-      html_badge = Utils.escape_html(badge.to_s.empty? ? msgs[:blocked_badge] : badge)
-      html_host = Utils.escape_html((host.to_s.empty? ? "shugoi.com" : host).slice(0, 120))
-      html_desc = Utils.escape_html(desc)
-      html_lang = locale == "fr" ? "fr" : "en"
-      '<!DOCTYPE html><html lang="' + html_lang + '"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><style>@font-face{font-family:\'Alex Brush\';src:url(https://shugoi.com/alex-brush.woff2?v=2) format(\'woff2\');font-display:swap}*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}html,body{height:100%;background:#fcf9f5}body{font-family:system-ui,-apple-system,\'Segoe UI\',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;padding:1.2rem}#c{max-width:460px;width:100%;background:#fff;border:4px solid #000;border-radius:28px 6px 32px 10px;box-shadow:12px 12px 0 #000;padding:3rem 2.4rem 2.8rem;text-align:center}#c .l{width:80px;height:80px;pointer-events:none;transform:rotate(-2.5deg);margin:0 auto .6rem;display:block}#c .b{display:block;margin:0 auto .2rem;pointer-events:none;max-width:100%;height:auto}#c .bdg{display:inline-block;border:2px solid #000;border-radius:10px 2px 14px 4px;padding:.3rem .9rem;font-size:.6rem;font-weight:700;text-transform:uppercase;letter-spacing:.1em;color:#E87090;margin-bottom:1.4rem}#c h2{font-family:\'Alex Brush\',Georgia,"Times New Roman",serif;font-size:2.2rem;color:#E87090;font-weight:400;margin:0 auto .6rem}#c p.desc{font-size:.9rem;color:#555;line-height:1.8;max-width:380px;margin:0 auto}#c p.ft{font-size:.55rem;color:#E87090;margin-top:1.8rem}</style></head><body><div id=c><img src=https://shugoi.com/favicon.png alt class=l><img src=https://shugoi.com/brand.png alt class=b><div class=bdg>' + html_badge + '</div><h2>' + html_title + '</h2><p class=desc>' + html_desc + '</p><p class=ft>' + html_host + ' \u00b7 Shugoi</p></div>' + countdown_script + '</body></html>'
-    end
+    def preflight_decision(ctx, ua)
+      return nil if @config.signing_secret.to_s.empty?
 
-    # 307 vers le challenge : body = tableau ASCII seul (curl le voit tel quel).
-    def pow_challenge_307(ctx)
-      ts = Utils.now_sec
-      nonce = SecureRandom.hex(8)
-      salt = Utils.hmac_hex(@config.signing_secret, "#{ts}:#{nonce}")
-      prefix = ctx[:forwarded_prefix].to_s
-      prefix = "" if prefix == "/"
-      prefix = prefix.sub(%r{/\z}, "") unless prefix.empty?
-      path = safe_challenge_path(ctx[:path].to_s)
-      chal_url = "#{prefix}/__sg_challenge?ts=#{ts}&salt=#{salt}&nonce=#{nonce}&diff=#{@config.pow_difficulty}&path=#{URI.encode_www_form_component(prefix + path)}"
-      Decision.new(status: 307, content_type: "text/plain", body: BLOCK_PAGE, headers: { "location" => chal_url })
-    end
+      proof = ctx[:sg_proof].to_s
+      valid_proof = !proof.empty? && @pow.valid?(proof)
+      valid_cookie = !ctx[:sg_ok].to_s.empty? && @pow.sg_ok_valid?(ctx[:sg_ok], ctx[:ip].to_s, ua)
+      proof_fresh = valid_proof ? consume_proof(proof) : false
+      return nil if valid_cookie || proof_fresh
+      return pow_challenge(ctx) if @challenge_limiter.allow?(ctx[:ip].to_s)
 
-    # Sanitisation open redirect (audit #5) : n'accepte qu'un chemin relatif commençant par
-    # UN SEUL '/', sans backslash ni caractères de contrôle.
-    def safe_challenge_path(p)
-      return "/" if p.to_s.empty?
-      return "/" unless p.start_with?("/")
-      return "/" if p.start_with?("//") || p.include?("\\")
-      return "/" if p.each_codepoint.any? { |c| c < 0x20 || c == 0x7f }
-
-      p
+      locale = Locales.resolve_locale(@config.locale, ctx[:accept_language])
+      rate_limit_decision(ctx, Locales.messages(locale), locale, 60, "1 min")
     end
 
-    # Anti-scraping : borne par IP l'émission de challenges (quota + backoff exponentiel).
-    def allow_challenge?(ip)
-      return true if ip.to_s.empty? || ip == "unknown"
+    def rate_limit_decision(ctx, messages, locale, remaining_seconds, remaining_text)
+      message = messages[:rate_limit_body].call(remaining_text)
+      body = if @config.block_page.respond_to?(:call)
+               @config.block_page.call(reason: "rate_limit", title: messages[:rate_limit_title],
+                                       message: message, badge: messages[:rate_limit_badge], host: ctx[:host].to_s,
+                                       remainingSeconds: remaining_seconds, locale: locale)
+             else
+               ShieldPage.render(title: messages[:rate_limit_title], message: message,
+                                 badge: messages[:rate_limit_badge], host: ctx[:host].to_s,
+                                 remaining_seconds: remaining_seconds, locale: locale)
+             end
+      Decision.new(status: 429, content_type: "text/html", body: body, headers: {})
+    end
 
-      now = Utils.now_ms
-      @mutex.synchronize do
-        e = @challenge_limits[ip]
-        if e.nil? || now - e[:window_start] >= CHALLENGE_WINDOW_MS
-          @challenge_limits[ip] = { count: 1, window_start: now, blocked_until: 0 }
-          return true
-        end
-        e[:count] += 1
-        return false if e[:blocked_until] > now
-        if e[:count] > CHALLENGE_LIMIT
-          backoff = [60_000 * (2**[e[:count] - CHALLENGE_LIMIT, 10].min), CHALLENGE_MAX_BLOCK_MS].min
-          e[:blocked_until] = now + backoff
-          e[:count] = 0
-          return false
-        end
-        true
-      end
+    def pow_challenge(ctx)
+      location = ChallengeUrl.build(secret: @config.signing_secret, difficulty: @config.pow_difficulty, context: ctx)
+      Decision.new(status: 307, content_type: "text/plain", body: BLOCK_PAGE, headers: { "location" => location })
     end
 
-    # Preuve PoW single-use GLOBAL (round 17) — clé = preuve seule (le nonce aléatoire
-    # la rend unique) → rejeu depuis N'IMPORTE QUEL IP → 307 (round 16 : clé ip:proof
-    # laissait le rejeu cross-IP → 200). Entrées purgées après POW_TTL_MS.
     def consume_proof(proof)
       @mutex.synchronize do
         return false if @used_proofs.key?(proof)
@@ -230,34 +116,5 @@ module Shugoi
         true
       end
     end
-
-    # Validation de la clé (lazy) + avertissement périodique si elle échoue.
-    def ensure_validated
-      return unless @config.secret
-      return if @validation_valid || @validation_failed
-
-      result = @api_client.validate_key(@config.site_key, @config.secret)
-      if result["valid"] == true
-        @validation_valid = true
-      else
-        @validation_failed = true
-      end
-    rescue StandardError
-      @validation_failed = true
-    end
-
-    def warn_if_validation_failed
-      return unless @config.secret
-      return unless @validation_failed
-      return if Utils.now_ms - @validation_warned_at < VALIDATION_WARN_INTERVAL
-
-      @validation_warned_at = Utils.now_ms
-      warn(
-        "[shugoi] La validation de la clé a échoué pour le siteKey #{@config.site_key}.\n" \
-        "[shugoi] La protection reste active, mais cette installation n'est pas authentifiée.\n" \
-        "[shugoi] Vérifiez `site_key` et `secret` : https://shugoi.com/docs#validation"
-      )
-      @api_client.post_event(@config.site_key, "validation_failed", "")
-    end
   end
 end

data/lib/shugoi/csp.rb

@@ -1,16 +1,8 @@
-# frozen_string_literal: true
-
 require "uri"
 
 module Shugoi
-  # Construction + fusion de la Content-Security-Policy — parité avec csp.ts (module Node).
-  # Le module npm pose la CSP fusionnée sur chaque réponse (y compris les pages passées) :
-  # la base inclut l'origine de l'API (pour le guard client), les directives additionnelles
-  # et, en split-render, `unsafe-eval` (nécessaire au bootcode eval([...])).
   class Csp
     SHUGOI_ORIGIN = "https://shugoi.com".freeze
-
-    # Retourne l'origine (schéma://host[:port]) d'une base URL, nil sinon.
     def self.origin_of(base_url)
       return nil if base_url.to_s.empty?
       u = URI.parse(base_url)
@@ -22,16 +14,13 @@ module Shugoi
       nil
     end
 
-    # @param site_key [String] siteKey (parité d'API avec le module Node, inutilisé dans la construction)
-    # @param api_origin [String, nil] origine de l'API Shugoi à autoriser (connect-src/script-src…)
-    # @param extra_directives [Hash<String, Array<String>>] directives additionnelles fusionnées
-    # @param split_render [Boolean] false → retire 'unsafe-eval' de script-src
-    # @return [String] header CSP
     def self.build(site_key:, api_origin: nil, extra_directives: {}, split_render: true)
+      _ = site_key
+      _ = split_render
       api = [SHUGOI_ORIGIN, api_origin].compact.uniq
       merged = {
         "default-src" => ["'self'"],
-        "script-src" => ["'self'", "'unsafe-inline'", "'unsafe-eval'", *api],
+        "script-src" => ["'self'", "'unsafe-inline'", *api],
         "connect-src" => ["'self'", *api],
         "style-src" => ["'self'", "'unsafe-inline'", *api],
         "font-src" => ["'self'", *api, "data:"],
@@ -44,15 +33,9 @@ module Shugoi
       extra_directives.each do |key, values|
         merged[key] = ((merged[key] || []) + Array(values)).uniq
       end
-      if split_render == false
-        merged["script-src"] = (merged["script-src"] || []).reject { |v| v == "'unsafe-eval'" }
-      end
       merged.map { |k, v| "#{k} #{v.join(' ')}" }.join("; ")
     end
 
-    # Fusionne une CSP existante (posée par l'app client) avec celle du module.
-    # Spec CSP : le mot-clé 'none' doit être SEUL dans une directive — sinon il est ignoré
-    # par le navigateur. Lors d'un merge, on garde uniquement 'none' (le plus restrictif).
     def self.merge(existing, added)
       return added if existing.to_s.empty?
       base = parse(existing)
@@ -65,7 +48,6 @@ module Shugoi
       base.map { |k, v| "#{k} #{v.to_a.join(' ')}" }.join("; ")
     end
 
-    # Parse une CSP en Hash<String, Set<String>>.
     def self.parse(csp)
       out = {}
       csp.to_s.split(";").each do |part|

data/lib/shugoi/errors.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Shugoi
   class Error < StandardError; end
   class ConfigError < Error; end

data/lib/shugoi/guard_cache.rb

@@ -1,12 +1,9 @@
-# frozen_string_literal: true
-
 require "monitor"
 
 module Shugoi
-  # Cache mémoire des guards (guard-detect) fetchés depuis l'API.
-  # Parité avec _guardCaches (render.ts).
   class GuardCache
     TTL_MS = 300_000
+    attr_reader :detect
 
     def initialize(api_client)
       @api_client = api_client
@@ -15,10 +12,6 @@ module Shugoi
       @mutex = Mutex.new
     end
 
-    def detect
-      @detect
-    end
-
     def ensure_ready(site_key, secret = nil)
       return if @detect && Utils.now_ms - @fetched_at < TTL_MS
 

data/lib/shugoi/guard_injector.rb

@@ -0,0 +1,31 @@
+module Shugoi
+  class GuardInjector
+    def initialize(config, token_signer, html_store, skeleton)
+      @config = config
+      @token_signer = token_signer
+      @html_store = html_store
+      @skeleton = skeleton
+    end
+
+    def call(html)
+      signed = @token_signer.sign(@config.site_key, Utils.now_ms)
+      config_script = @config.restricted_access ? "" : "<script>window.__sg_disableRestrictedAccess=true</script>"
+      injected = insert_config(html, config_script)
+      @html_store.store(signed, injected, @config.site_key)
+      @skeleton.generate(@config.site_key, signed, @config.base_url, "./__shugoi/render")
+    end
+
+    private
+
+    def insert_config(html, config_script)
+      if (index = html.index("</head>"))
+        html[0...index] + config_script + html[index..]
+      elsif (match = html.match(/<body[^>]*>/))
+        index = html.index(match[0]) + match[0].length
+        html[0...index] + config_script + html[index..]
+      else
+        config_script + html
+      end
+    end
+  end
+end

data/lib/shugoi/html_store.rb

@@ -1,8 +1,4 @@
-# frozen_string_literal: true
-
 module Shugoi
-  # Stockage mémoire (et disque optionnel) du HTML rendu, lié au token.
-  # Parité avec _memoryStore/_siteCache (render.ts).
   class HtmlStore
     TOKEN_TTL_MS = 120_000
     MAX_ENTRIES = 5000
@@ -26,6 +22,7 @@ module Shugoi
         while (@entries.size >= MAX_ENTRIES || @total_bytes + size > MAX_TOTAL_BYTES) && !@entries.empty?
           drop_unlocked(@entries.keys.first)
         end
+        drop_unlocked(token)
         @entries[token] = Entry.new(html, Utils.now_ms + TOKEN_TTL_MS, 0)
         @site_cache[site_key] = html
         @total_bytes += size
@@ -33,7 +30,6 @@ module Shugoi
       end
     end
 
-    # @return [String, nil] html si présent et lisible
     def read(token)
       @mutex.synchronize do
         entry = @entries[token]

data/lib/shugoi/key_validator.rb

@@ -0,0 +1,36 @@
+module Shugoi
+  class KeyValidator
+    WARN_INTERVAL_MS = 3_600_000
+
+    def initialize(config, api_client)
+      @config = config
+      @api_client = api_client
+      @valid = false
+      @failed = false
+      @warned_at = 0
+    end
+
+    def validate
+      return unless @config.secret
+      return if @valid || @failed
+
+      @valid = @api_client.validate_key(@config.site_key, @config.secret)["valid"] == true
+      @failed = !@valid
+    rescue StandardError
+      @failed = true
+    end
+
+    def warn_if_failed
+      return unless @config.secret && @failed
+      return if Utils.now_ms - @warned_at < WARN_INTERVAL_MS
+
+      @warned_at = Utils.now_ms
+      warn(
+        "[shugoi] La validation de la clé a échoué pour le siteKey #{@config.site_key}.\n" \
+        "[shugoi] La protection reste active, mais cette installation n'est pas authentifiée.\n" \
+        "[shugoi] Vérifiez `site_key` et `secret` : https://shugoi.com/docs#validation"
+      )
+      @api_client.post_event(@config.site_key, "validation_failed", "")
+    end
+  end
+end

data/lib/shugoi/locales.rb

@@ -1,29 +1,35 @@
-# frozen_string_literal: true
-
 module Shugoi
-  # Messages localisés des pages de blocage — parité avec locales.ts (module Node).
   module Locales
     FR = {
       rate_limit_title: "Trop de requêtes",
-      rate_limit_body: ->(t) { "Vous avez effectué trop de requêtes en peu de temps. Il reste #{t} avant de pouvoir réessayer." },
+      rate_limit_body: lambda { |t|
+        "Vous avez effectué trop de requêtes en peu de temps. Il reste #{t} avant de pouvoir réessayer."
+      },
       rate_limit_badge: "Rate Limit",
       blocked_title: "Accès bloqué",
       blocked_badge: "Blocage",
       tamper_title: "Remplacement de contenu client détecté",
-      tamper_body: "Nous avons remarqué que vous avez tenté de modifier manuellement le rendu client côté navigateur via les DevTools. Cette pratique est évidemment bloquée par nos services.",
-      devtools_body: "L'utilisation des DevTools pour remplacer le contenu ou modifier les requêtes réseau a été détectée. L'intégrité de la page est protégée et toute altération est immédiatement bloquée.",
+      tamper_body: "Nous avons remarqué que vous avez tenté de modifier manuellement le rendu client côté navigateur " \
+                   "via les DevTools. Cette pratique est évidemment bloquée par nos services.",
+      devtools_body: "L'utilisation des DevTools pour remplacer le contenu ou modifier les requêtes réseau " \
+                     "a été détectée. L'intégrité de la page est protégée et toute altération est " \
+                     "immédiatement bloquée.",
       retry_in_seconds: ->(s) { "Il reste #{s}s avant de pouvoir réessayer." }
     }.freeze
 
     EN = {
       rate_limit_title: "Too Many Requests",
-      rate_limit_body: ->(t) { "You have made too many requests in a short time. #{t} remaining before you can try again." },
+      rate_limit_body: lambda { |t|
+        "You have made too many requests in a short time. #{t} remaining before you can try again."
+      },
       rate_limit_badge: "Rate Limit",
       blocked_title: "Access Blocked",
       blocked_badge: "Blocked",
       tamper_title: "Client Content Replacement Detected",
-      tamper_body: "We noticed you attempted to manually modify the client-side rendering via DevTools. This practice is obviously blocked by our services.",
-      devtools_body: "Using DevTools to replace content or modify network requests has been detected. Page integrity is protected and any alteration is immediately blocked.",
+      tamper_body: "We noticed you attempted to manually modify the client-side rendering via DevTools. " \
+                   "This practice is obviously blocked by our services.",
+      devtools_body: "Using DevTools to replace content or modify network requests has been detected. " \
+                     "Page integrity is protected and any alteration is immediately blocked.",
       retry_in_seconds: ->(s) { "Retry in #{s}s." }
     }.freeze