robust_server_socket 0.4.2 → 0.4.3

data/README.md

@@ -17,6 +17,8 @@ Gem для межсервисной аутентификации, использ
 - **DDoS-атаками**: Необходимость ограничения частоты запросов
 - **Boilerplate кодом**: Повторяющаяся логика валидации в каждом сервисе
 
+#### Даже если инфраструктура находится за DMZ, в своей локальной сети, остаётся пространство для SSRF или OpenRedirect атак
+
 ### Решение
 
 RobustServerSocket предоставляет:
@@ -24,7 +26,7 @@ RobustServerSocket предоставляет:
 - **RSA-дешифрование**: Проверка подлинности токенов
 - **Whitelist клиентов**: Только разрешённые сервисы
 - **Защиту от replay**: Блэклист использованных токенов в Redis
-- **Rate limiting**: Ограничение запросов на клиента
+- **Rate limiting**: Скользящее окно запросов на клиента
 
 ## КАК ЭТО РАБОТАЕТ (HOW)
 
@@ -54,18 +56,18 @@ RobustServerSocket предоставляет:
 ### Поток валидации
 
 1. **Расшифровка**: Base64 decode → RSA decrypt с приватным ключом
-2. **Парсинг**: Извлечение `{client_name}_{timestamp}` из токена
+2. **Парсинг**: Извлечение `{client_name}_{timestamp_ms}` из токена
 3. **Whitelist**: Проверка client_name в `allowed_services`
-4. **Rate limit**: Проверка количества запросов в окне
+4. **Rate limit**: Скользящее окно — проверка количества запросов за `rate_limit_window_seconds`
 5. **Replay check**: Проверка, что токен не использован (Redis)
-6. **Staleness**: Проверка timestamp на актуальность
+6. **Staleness**: Проверка timestamp на актуальность (с допуском ±30 секунд на рассинхрон часов)
 
 ### Модульная система
 
 Проверки подключаются через `using_modules`:
 - `:client_auth_protection` — whitelist клиентов
-- `:replay_attack_protection` — защита от повторного использования
-- `:dos_attack_protection` — rate limiting
+- `:replay_attack_protection` — защита от повторного использования токена
+- `:rate_limit_protection` — rate limiting по скользящему окну
 
 ## 📋 Содержание
 
@@ -88,21 +90,19 @@ RobustServerSocket реализует многоуровневую систем
 - **Идентификация по имени**: Каждый клиент должен быть явно указан в `allowed_services`
 
 ### 3. Защита от перехвата токенов (replay-attack)
-- **Защита от replay-attack**: использованные токены добавляются в черный список и имеют время жизни, при включенном модуле `:replay_attack_protection`
-- **Staleness**: Токены автоматически становятся недействительными после истечения времени
-- **Blacklisting использованных токенов**: Redis как хранилище черного списка
-- **Настраиваемое время жизни токенов в черном списке**: по умолчанию 10 минут
-- **Настраиваемое ttl токена**: Должно быть в окно ответа между серверами, по умолчанию 10сек
-
-### 4. Защита от DoS
-- **Защита от DDoS**: Ограничение количества запросов от каждого клиента, при включенном модуле `:dos_attack_protection`
-- **Sliding window**: Распределение запросов во времени
-- **Fail-open стратегия**: Если Redis недоступен, запросы пропускаются (для надёжности)
-
--
+- **Защита от replay-attack**: использованные токены добавляются в черный список, при включенном модуле `:replay_attack_protection`
+- **Staleness**: Токены автоматически становятся недействительными после истечения `token_expiration_time`
+- **Допуск на рассинхрон часов**: ±30 секунд (CLOCK_SKEW)
+- **TTL блэклиста**: вычисляется автоматически как `token_expiration_time + CLOCK_SKEW`
+
+### 4. Rate limiting
+- **Скользящее окно**: при включенном модуле `:rate_limit_protection` — точный подсчёт запросов без граничного burst-эффекта фиксированного окна
+- **Fail-open стратегия**: если Redis недоступен, запросы пропускаются (для надёжности сервиса)
+- **Изоляция по клиентам**: лимит считается отдельно для каждого `client_name`
+
 ### 5. Защита от SSL stripping MITM attack
 - **Принудительное HTTPS на сервере**: Все запросы должны быть совершены по HTTPS, чтобы защитить токены от перехвата
-- **Включается на RobustClientSoket, ключём `ssl_verify: true`**
+- **Включается на RobustClientSocket, ключём `ssl_verify: true`**
 
 ## 📦 Установка
 
@@ -114,6 +114,7 @@ gem 'robust_server_socket'
 ```ruby
 gem 'robust_client_socket'
 ```
+
 ## ⚙️ Конфигурация
 
 Создайте файл `config/initializers/robust_server_socket.rb`:
@@ -121,140 +122,119 @@ gem 'robust_client_socket'
 ```ruby
 RobustServerSocket.configure do |c|
   c.using_modules = %i[
-    :client_auth_protection
-    :replay_attack_protection
-    :dos_attack_protection
+    client_auth_protection
+    replay_attack_protection
+    rate_limit_protection
   ]
-  
+
   # Приватный ключ сервиса (RSA-2048 или выше)
   c.private_key = ENV['ROBUST_SERVER_PRIVATE_KEY']
-  c.token_expiration_time = 3
-  
+
+  # Время жизни токена в секундах (должно совпадать с TTL на клиенте)
+  c.token_expiration_time = 10
+
   # Список разрешённых сервисов (whitelist)
-  # Должен совпадать с именами RobustClientSocket клиента
-  # Для client_auth_protection
+  # Должен совпадать с service_name RobustClientSocket клиента
   c.allowed_services = %w[core payments notifications]
-  
-  # Redis для работы replay_attack_protection и ddos_attack_protection
+
+  # Redis для replay_attack_protection и rate_limit_protection
   c.redis_url = ENV.fetch('REDIS_URL', 'redis://localhost:6379/0')
   c.redis_pass = ENV['REDIS_PASSWORD']
 
-  # ddos_attack_protection
-  # Максимальное количество запросов в окне времени (по умолчанию: 100)
-  c.rate_limit_max_requests = 100
-  # Размер временного окна в секундах (по умолчанию: 60)
-  c.rate_limit_window_seconds = 60
+  # rate_limit_protection
+  c.rate_limit_max_requests = 100   # максимум запросов в окне (по умолчанию: 100)
+  c.rate_limit_window_seconds = 60  # размер окна в секундах (по умолчанию: 60)
 end
 
-# Загрузка конфигурации с валидацией
 RobustServerSocket.load!
 ```
-`using_modules` - это используемые модули, добавление или удаление которых изменит поведение гема.
-
-### Опции конфигурации сервиса
-
-| Параметр                    | Тип | Обязательный | Default                                                                      | Описание                                        |
-|-----------------------------|-----|-------------|------------------------------------------------------------------------------|-------------------------------------------------|
-| `private_key`               | String | ✅ | -                                                                            | Приватный RSA ключ сервиса (RSA-2048 или выше)  |
-| `token_expiration_time`     | Integer | ✅ | 10                                                                           | Время жизни токена в секундах                   |
-| `store_used_token_time`     | Integer | ✅ | 600                                                                          | Время жизни токена в блеклисте в секундах       |
-| `allowed_services`          | Array | ❌ | -                                                                            | Список разрешённых сервисов (whitelist)         |
-| `redis_url`                 | String | ✅ | -                                                                            | URL для подключения к Redis                     |
-| `using_modules`             | Array | ❌ | [:client_auth_protection, :replay_attack_protection, :dos_attack_protection] | Используемые модули                             |
-| `redis_pass`                | String | ❌ | nil                                                                          | Пароль для Redis (если требуется)               |
-| `rate_limit_max_requests`   | Integer | ❌ | 100                                                                          | Максимальное количество запросов в окне времени |
-| `rate_limit_window_seconds` | Integer | ❌ | 60                                                                           | Размер временного окна в секундах               |
+
+### Опции конфигурации
+
+| Параметр                    | Тип     | Обязательный | Default                                                                             | Описание                                        |
+|-----------------------------|---------|-------------|-------------------------------------------------------------------------------------|-------------------------------------------------|
+| `private_key`               | String  | ✅          | —                                                                                   | Приватный RSA ключ сервиса (RSA-2048 или выше)  |
+| `token_expiration_time`     | Integer | ✅          | 10                                                                                  | Время жизни токена в секундах                   |
+| `allowed_services`          | Array   | ✅          | —                                                                                   | Список разрешённых сервисов (whitelist)         |
+| `redis_url`                 | String  | ✅          | —                                                                                   | URL для подключения к Redis                     |
+| `redis_pass`                | String  | ❌          | nil                                                                                 | Пароль для Redis                                |
+| `using_modules`             | Array   | ❌          | `[:client_auth_protection, :rate_limit_protection, :replay_attack_protection]`      | Используемые модули                             |
+| `rate_limit_max_requests`   | Integer | ❌          | 100                                                                                 | Максимальное количество запросов в окне         |
+| `rate_limit_window_seconds` | Integer | ❌          | 60                                                                                  | Размер временного окна в секундах               |
+
+> `store_used_token_time` больше не является конфигурируемым — вычисляется автоматически как `token_expiration_time + 30` (CLOCK_SKEW).
+
+### Совместимость с RobustClientSocket
+
+Токен содержит таймстамп в **миллисекундах**. RobustClientSocket начиная с версии X.X должен генерировать:
+
+```ruby
+Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+```
+
+Устаревший `Time.now.utc.to_i` (секунды) приведёт к тому, что все токены будут отклонены как `stale`.
 
 ## 🚀 Использование
 
 ### Базовая авторизация
 
 ```ruby
-# В контроллере или middleware
 class ApiController < ApplicationController
   before_action :authenticate_service!
-  
+
   private
-  
+
   def authenticate_service!
-    # Хедер, прописанный в RobustClientSocket (SECURE-TOKEN default)
     token = request.headers['SECURE-TOKEN']&.sub(/^Bearer /, '')
-    
-    @current_service = RobustServerSocket::ClientToken.validate!(token) # bang method (рейзит ошибки)
+    @current_service = RobustServerSocket::ClientToken.validate!(token)
   rescue RobustServerSocket::ClientToken::InvalidToken
     render json: { error: 'Invalid token' }, status: :unauthorized
-  rescue RobustServerSocket::ClientToken::UnauthorizedClient
+  rescue RobustServerSocket::Modules::ClientAuthProtection::UnauthorizedClient
     render json: { error: 'Unauthorized service' }, status: :forbidden
-  rescue RobustServerSocket::ClientToken::UsedToken
+  rescue RobustServerSocket::Modules::ReplayAttackProtection::UsedToken
     render json: { error: 'Token already used' }, status: :unauthorized
-  rescue RobustServerSocket::ClientToken::StaleToken
+  rescue RobustServerSocket::Modules::ReplayAttackProtection::StaleToken
     render json: { error: 'Token expired' }, status: :unauthorized
   rescue RobustServerSocket::RateLimiter::RateLimitExceeded => e
     render json: { error: e.message }, status: :too_many_requests
   end
-  
-  def authenticate_service
-    token = request.headers['SECURE-TOKEN']&.sub(/^Bearer /, '')
-    @current_service = RobustServerSocket::ClientToken.valid?(token) # не рейзит
-    
-    if @current_service
-      # Токен валиден
-    else
-      # Токен невалиден
-      render json: { error: 'Unauthorized' }, status: :unauthorized
-    end
-  end
 end
 ```
 
-### Расширенное использование
+### valid? (не рейзит)
 
 ```ruby
-# Создание объекта токена
-token_string = request.headers['Authorization']&.sub(/^Bearer /, '')
-client_token = RobustServerSocket::ClientToken.new(token_string)
+token = request.headers['SECURE-TOKEN']&.sub(/^Bearer /, '')
+client_token = RobustServerSocket::ClientToken.new(token)
 
-# Проверка валидности (возвращает true/false)
 if client_token.valid?
-  # Получение имени клиента
   client_name = client_token.client
-  puts "Authorized client: #{client_name}"
 else
-  # Токен невалиден
   render json: { error: 'Unauthorized' }, status: :unauthorized
 end
-
-# Быстрая валидация с исключениями
-begin
-  service_token = RobustServerSocket::ClientToken.validate!(token_string)
-  client_name = service_token.client
-rescue => e
-  # Обработка специфичных ошибок
-end
 ```
 
 ## ❌ Обработка ошибок
 
 ### Типы исключений
 
-| Исключение | Причина | HTTP статус | Действие |
-|-----------|---------|-------------|----------|
-| `InvalidToken` | Токен не может быть расшифрован или имеет неверный формат | 401 | Проверьте корректность токена и ключей |
-| `UnauthorizedClient` | Клиент не в whitelist | 403 | Добавьте клиента в `allowed_services` |
-| `UsedToken` | Токен уже был использован | 401 | Клиент должен запросить новый токен |
-| `StaleToken` | Токен истёк | 401 | Клиент должен запросить новый токен |
-| `RateLimitExceeded` | Превышен лимит запросов | 429 | Клиент должен подождать или ретраить позже |
+| Исключение                                              | Причина                                      | HTTP статус |
+|---------------------------------------------------------|----------------------------------------------|-------------|
+| `ClientToken::InvalidToken`                             | Токен не расшифрован или неверный формат     | 401         |
+| `Modules::ClientAuthProtection::UnauthorizedClient`     | Клиент не в whitelist                        | 403         |
+| `Modules::ReplayAttackProtection::UsedToken`            | Токен уже был использован                    | 401         |
+| `Modules::ReplayAttackProtection::StaleToken`           | Токен истёк или из будущего (>30s)           | 401         |
+| `RateLimiter::RateLimitExceeded`                        | Превышен лимит запросов                      | 429         |
 
 ### Централизованная обработка
 
 ```ruby
-# В ApplicationController
 rescue_from RobustServerSocket::ClientToken::InvalidToken,
-            RobustServerSocket::ClientToken::UsedToken,
-            RobustServerSocket::ClientToken::StaleToken,
+            RobustServerSocket::Modules::ReplayAttackProtection::UsedToken,
+            RobustServerSocket::Modules::ReplayAttackProtection::StaleToken,
             with: :unauthorized_response
 
-rescue_from RobustServerSocket::ClientToken::UnauthorizedClient,
+rescue_from RobustServerSocket::Modules::ClientAuthProtection::UnauthorizedClient,
             with: :forbidden_response
 
 rescue_from RobustServerSocket::RateLimiter::RateLimitExceeded,
@@ -263,26 +243,17 @@ rescue_from RobustServerSocket::RateLimiter::RateLimitExceeded,
 private
 
 def unauthorized_response(exception)
-  render json: {
-    error: 'Authentication failed',
-    message: exception.message,
-    type: exception.class.name
-  }, status: :unauthorized
+  render json: { error: 'Authentication failed', message: exception.message }, status: :unauthorized
 end
 
 def forbidden_response(exception)
-  render json: {
-    error: 'Access denied',
-    message: exception.message,
-    type: exception.class.name
-  }, status: :forbidden
+  render json: { error: 'Access denied', message: exception.message }, status: :forbidden
 end
 
 def rate_limit_response(exception)
   render json: {
     error: 'Too many requests',
     message: exception.message,
-    type: exception.class.name,
     retry_after: RobustServerSocket.configuration.rate_limit_window_seconds
   }, status: :too_many_requests
 end
@@ -290,8 +261,6 @@ end
 
 ## 🤝 Интеграция с RobustClientSocket
 
-Для полноценной работы необходимо настроить клиентскую часть:
-
 ```ruby
 # На клиенте (RobustClientSocket)
 RobustClientSocket.configure do |c|
@@ -299,21 +268,25 @@ RobustClientSocket.configure do |c|
   c.keychain = {
     payments: {
       base_uri: 'https://payments.example.com',
-      public_key: '-----BEGIN PUBLIC KEY-----...' # Публичный ключ сервера payments
+      public_key: '-----BEGIN PUBLIC KEY-----...'
     }
   }
 end
 
 # На сервере (RobustServerSocket)
 RobustServerSocket.configure do |c|
-  c.allowed_services = %w[core] # ← Соответствует service_name клиента
-  c.private_key = '-----BEGIN PRIVATE KEY-----...' # Приватная пара к public_key
+  c.allowed_services = %w[core]
+  c.private_key = '-----BEGIN PRIVATE KEY-----...'
 end
 ```
 
+## 🗺️ TODO
+
+- [ ] **Per-client ключи для rate limiter** — настраиваемые индивидуальные лимиты для каждого `client_name` вместо единого глобального лимита
+
 ## 📚 Дополнительные ресурсы
 
-- [RobustClientSocket documentation](https://github.com/tee0zed/robust_client_socket)
+- [RobustClientSocket](https://github.com/tee0zed/robust_client_socket)
 - [RSA encryption best practices](https://www.openssl.org/docs/)
 - [Redis security guide](https://redis.io/topics/security)
 

data/Rakefile

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :test
+task default: :spec

data/lib/robust_server_socket/cacher.rb

@@ -1,35 +1,32 @@
+# frozen_string_literal: true
+
 module RobustServerSocket
-  module Cacher
+  module Cacher # rubocop:disable Metrics/ModuleLength
     class RedisConnectionError < StandardError; end
 
-    class << self
-      # Atomically validate token: check expiration and usage, then mark as used
-      # Returns: 'ok', 'stale', or 'used'
-      def atomic_validate_and_log(key, ttl, timestamp, expiration_time)
-        current_time = Time.now.utc.to_i
+    CLOCK_SKEW_MS = 30_000
 
+    class << self # rubocop:disable Metrics/ClassLength
+      def atomic_validate_and_log(key, ttl, timestamp_ms, expiration_time)
+        current_ms = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
         redis.with do |conn|
-          conn.eval(
-            lua_atomic_validate_and_log,
-            keys: [key],
-            argv: [ttl, timestamp, expiration_time, current_time]
-          )
+          conn.eval(lua_atomic_validate_and_log, keys: [key],
+                                                 argv: [ttl, timestamp_ms, expiration_time, current_ms])
         end
       rescue ::Redis::BaseConnectionError => e
         handle_redis_error(e, 'atomic_validate_and_log')
         raise RedisConnectionError, "Failed to validate token: #{e.message}"
       end
 
-      def incr(key)
+      def incr_sliding_window_count(key, window_seconds)
+        now_ns = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
         redis.with do |conn|
-          conn.pipelined do |pipeline|
-            pipeline.incrby(key, 1)
-            pipeline.expire(key, ttl_seconds)
-          end
+          conn.eval(lua_sliding_window, keys: [key],
+                                        argv: [now_ns, window_seconds * 1_000_000_000, window_seconds, now_ns.to_s])
         end
       rescue ::Redis::BaseConnectionError => e
-        handle_redis_error(e, 'incr')
-        raise RedisConnectionError, "Failed to increment key: #{e.message}"
+        handle_redis_error(e, 'incr_sliding_window_count')
+        raise RedisConnectionError, "Failed to count sliding window: #{e.message}"
       end
 
       def get(key)
@@ -53,52 +50,65 @@ module RobustServerSocket
         redis.with(&block)
       rescue ::Redis::BaseConnectionError => e
         handle_redis_error(e, 'with_redis')
-        raise ::RedisConnectionError, "Redis operation failed: #{e.message}"
+        raise RedisConnectionError, "Redis operation failed: #{e.message}"
       end
 
       # Clear cached Redis connection pool (useful for hot reloading in development)
       def clear_redis_pool_cache!
-        @pool = nil
+        @redis = nil
       end
 
       private
 
+      def lua_sliding_window
+        <<~LUA
+          local key = KEYS[1]
+          local now_ns = tonumber(ARGV[1])
+          local window_ns = tonumber(ARGV[2])
+          local window_s = tonumber(ARGV[3])
+          local member = ARGV[4]
+
+          redis.call('ZREMRANGEBYSCORE', key, '-inf', now_ns - window_ns)
+          redis.call('ZADD', key, now_ns, member)
+          redis.call('EXPIRE', key, window_s)
+          return redis.call('ZCARD', key)
+        LUA
+      end
+
       def lua_atomic_validate_and_log
         <<~LUA
           local key = KEYS[1]
           local ttl = tonumber(ARGV[1])
-          local timestamp = tonumber(ARGV[2])
-          local expiration_time = tonumber(ARGV[3])
-          local current_time = tonumber(ARGV[4])
-                  
-          -- Check if token is expired
-          if expiration_time <= (current_time - timestamp) then
+          local timestamp_ms = tonumber(ARGV[2])
+          local expiration_ms = tonumber(ARGV[3]) * 1000
+          local current_ms = tonumber(ARGV[4])
+
+          if timestamp_ms > current_ms + #{CLOCK_SKEW_MS} then
             return 'stale'
           end
-                  
+
+          if expiration_ms <= (current_ms - timestamp_ms) then
+            return 'stale'
+          end
+
           -- Check if token was already used
           local current = redis.call('GET', key)
           if current and tonumber(current) > 0 then
             return 'used'
           end
-                  
+
           -- Mark token as used
           redis.call('INCRBY', key, 1)
           redis.call('EXPIRE', key, ttl)
-                  
+
           return 'ok'
         LUA
       end
 
-      def ttl_seconds
-        # `+ 10` secs, for token storing and expiration check validity
-        ::RobustServerSocket.configuration.token_expiration_time + 10
-      end
-
       # Cache Redis connection pool at module level for the lifetime of the Rails process
       # This avoids recreating the connection pool on every Redis operation
       def redis
-        @pool ||= ::ConnectionPool::Wrapper.new(**pool_config) do
+        @redis ||= ::ConnectionPool::Wrapper.new(**pool_config) do
           ::Redis.new(redis_config)
         end
       end

data/lib/robust_server_socket/client_token.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RobustServerSocket
   class ClientToken
     TOKEN_REGEXP = /\A(.+)_(\d{10,})\z/.freeze
@@ -5,9 +7,7 @@ module RobustServerSocket
     InvalidToken = Class.new(StandardError)
 
     def self.validate!(secure_token)
-      new(secure_token).tap do |instance|
-        instance.validate!
-      end
+      new(secure_token).tap(&:validate!)
     end
 
     def initialize(secure_token)
@@ -16,12 +16,13 @@ module RobustServerSocket
     end
 
     def validate!
-      raise InvalidToken unless validate_decrypted_token
       modules_checks!
+    rescue SecureToken::InvalidToken => e
+      raise InvalidToken, e.message
     end
 
     def valid?
-      validate_decrypted_token && modules_checks
+      modules_checks
     rescue StandardError
       false
     end
@@ -45,10 +46,6 @@ module RobustServerSocket
       @decrypted_token ||= SecureToken::Decrypt.call(@secure_token)
     end
 
-    def validate_decrypted_token
-      !!decrypted_token
-    end
-
     private
 
     def allowed_clients
@@ -67,6 +64,7 @@ module RobustServerSocket
       @split_token ||= begin
         match_data = decrypted_token.to_s.match(TOKEN_REGEXP)
         raise InvalidToken, 'Invalid token format' unless match_data
+
         match_data.captures
       end
     end
@@ -75,7 +73,6 @@ module RobustServerSocket
       RobustServerSocket.configuration.token_expiration_time
     end
 
-
     # Do we need it? It would be useful only if public_key compromised
     # def secure_compare(a, b)
     #   return false unless a.bytesize == b.bytesize
@@ -89,6 +86,9 @@ module RobustServerSocket
       raise InvalidToken, 'Token cannot be empty' if token.empty?
       raise InvalidToken, 'Token too long' if token.length > 2048
 
+      # Check for null-byte injection
+      raise InvalidToken, 'Token contains invalid characters' if token.include?("\x00")
+
       token
     end
   end

data/lib/robust_server_socket/configuration.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module RobustServerSocket
   module Configuration
     MIN_KEY_SIZE = 2048
 
+    ConfigurationError = Class.new(StandardError)
+
     attr_reader :configuration, :configured
 
     def _push_modules_check_code(code)
@@ -15,6 +19,7 @@ module RobustServerSocket
     def configure
       @configuration ||= ConfigStore.new
       yield(configuration)
+      validate_configuration!
       validate_key_security!
 
       @configured = true
@@ -37,13 +42,25 @@ module RobustServerSocket
 
     private
 
+    def validate_configuration!
+      validate_positive!(:rate_limit_max_requests)
+      validate_positive!(:rate_limit_window_seconds)
+      validate_positive!(:token_expiration_time)
+    end
+
+    def validate_positive!(attr)
+      return if configuration.public_send(attr).to_i.positive?
+
+      raise ConfigurationError, "#{attr} must be positive"
+    end
+
     def validate_key_security!
       key = ::OpenSSL::PKey::RSA.new(configuration.private_key)
       key_bits = key.n.num_bits
 
       if key_bits < MIN_KEY_SIZE
         raise SecurityError,
-          "RSA key size (#{key_bits} bits) below minimum (#{MIN_KEY_SIZE} bits)"
+              "RSA key size (#{key_bits} bits) below minimum (#{MIN_KEY_SIZE} bits)"
       end
     rescue ::OpenSSL::PKey::RSAError => e
       raise SecurityError, "Invalid private key: #{e.message}"
@@ -51,7 +68,8 @@ module RobustServerSocket
   end
 
   class ConfigStore
-    attr_accessor :allowed_services, :private_key, :token_expiration_time, :store_used_token_time, :redis_url, :redis_pass,
+    attr_accessor :allowed_services, :private_key, :token_expiration_time,
+                  :redis_url, :redis_pass,
                   :rate_limit_max_requests, :rate_limit_window_seconds, :using_modules
 
     attr_reader :_modules_check_rows, :_bang_modules_check_rows
@@ -59,14 +77,8 @@ module RobustServerSocket
     def initialize
       @rate_limit_max_requests = 100
       @rate_limit_window_seconds = 60
-      @store_used_token_time = 600
       @token_expiration_time = 10
-      @using_modules = %i[
-        client_auth_protection
-        dos_attack_protection
-        replay_attack_protection
-      ]
-
+      @using_modules = %i[client_auth_protection rate_limit_protection replay_attack_protection]
       @_modules_check_rows = []
       @_bang_modules_check_rows = []
     end

data/lib/robust_server_socket/modules/client_auth_protection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RobustServerSocket
   module Modules
     module ClientAuthProtection