spamtrap 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ab3ea3a6d506bbc30ec82be0f584e51dbe9c51cc93b0677d9e97edc9d8ea47
-  data.tar.gz: 6c3667c9e712016f6f668db20e4e7e175290e148f4d259032a6400b9bf75986c
+  metadata.gz: 619741f1ea048808a9235e1bc02a814c2d6606aed599e188c3ea99d464e2fc85
+  data.tar.gz: e309645da54a5ac5c898b83f8e90b5132361001724469ceabe18bf7f3195fbac
 SHA512:
-  metadata.gz: 753c5c75e6a39d958b647bc45ee1e433f59f05c514a702e35e532f6a1dfc8abcb0dfeeecf5edbb3c0d489c488ec093fddb9c3cc342dab2f71027cd5a8f483ac6
-  data.tar.gz: f5896fef5cad634cb91e2d46c52ab5b1fca74fbc76a9061fc05e209b793b0ddd8d066770ec02c33f74a45e565687ae63778140bfc5a8d485164809a0581b0a65
+  metadata.gz: 9e8328c22c89ee565ef34c2cff0e2ecad4aae2b9e71a9627bb6162e57e1013577fa53f65a56a217928e8d0503017b4c2508cec435ecf0c911eb257da53087f59
+  data.tar.gz: 49fa2e0f20b2489eb082c9bd4cd3fe1a09f4d4ddd03022676e12a91fc7779a0bab36e1a628205a0a1f29904da8292a984ef11a317bda486eed0c74f1a5d42909

data/lib/spamtrap/controller.rb

@@ -1,4 +1,5 @@
 module Spamtrap::Controller
+  include Spamtrap::Crypto
 
   def self.included(base)
     base.extend ActsAsMethods
@@ -6,18 +7,70 @@ module Spamtrap::Controller
 
   module ActsAsMethods
     def spamtrap(honeypot = 'spamtrap', options = {}, &block)
+      # Capture explicit per-call values; use sentinel so globals are read
+      # at request time rather than at class definition time.
+      nonce_opt   = options.key?(:nonce)         ? options.delete(:nonce)         : :global
+      timeout_opt = options.key?(:nonce_timeout) ? options.delete(:nonce_timeout) : :global
+      mutate_opt  = options.key?(:mutate)        ? options.delete(:mutate)        : :global
+
       before_action(options) do |controller|
         controller.instance_eval(&block) if block_given?
         controller.instance_eval do
+          nonce_enabled  = nonce_opt   == :global ? Spamtrap.nonce         : nonce_opt
+          nonce_timeout  = timeout_opt == :global ? Spamtrap.nonce_timeout : timeout_opt
+          mutate_enabled = mutate_opt  == :global ? Spamtrap.mutate        : mutate_opt
+
+          spamtrap_remap_params if mutate_enabled
+
           if params[honeypot].present?
             Rails.logger.warn "Spamtrap triggered by #{request.remote_ip}."
             head 200
+          elsif nonce_enabled && !spamtrap_valid_nonce?(nonce_timeout)
+            Rails.logger.warn "Spamtrap nonce invalid from #{request.remote_ip}."
+            head 200
           end
         end
       end
     end
   end
 
+  def spamtrap_valid_nonce?(timeout)
+    timestamp = params[:spamtrap_timestamp].to_i
+    nonce = params[:spamtrap_nonce].to_s
+    return false if timestamp.zero? || nonce.empty?
+    return false if Time.now.to_i - timestamp > timeout.to_i
+
+    secret = Rails.application.secret_key_base
+    expected = OpenSSL::HMAC.hexdigest('SHA256', secret, "#{timestamp}:#{request.remote_ip}")
+    ActiveSupport::SecurityUtils.secure_compare(nonce, expected)
+  end
+
+  def spamtrap_remap_params
+    salt_hex = params[:spamtrap_mutation_salt].to_s
+    return if salt_hex.empty?
+
+    salt_bytes = [salt_hex].pack('H*')
+    return unless salt_bytes.bytesize == Spamtrap::Crypto::NONCE_LEN
+
+    spamtrap_remap_hash(params, salt_bytes)
+  rescue ArgumentError
+    nil
+  end
+
+  def spamtrap_remap_hash(hash, salt)
+    hash.each_key.to_a.each do |key|
+      real = spamtrap_decrypt_field(key.to_s, salt)
+      if real
+        hash[real] = hash.delete(key)
+        key = real
+      end
+      child = hash[key]
+      spamtrap_remap_hash(child, salt) if child.is_a?(ActionController::Parameters)
+    end
+  end
+
+  private :spamtrap_valid_nonce?, :spamtrap_remap_params, :spamtrap_remap_hash
+
 end
 
 ActionController::Base.send :include, Spamtrap::Controller

data/lib/spamtrap/crypto.rb

@@ -0,0 +1,46 @@
+require 'base64'
+
+module Spamtrap
+  module Crypto
+    CIPHER    = 'aes-128-gcm'
+    KEY_LEN   = 16
+    NONCE_LEN = 12
+    TAG_LEN   = 16
+
+    private
+
+    def spamtrap_crypto_key
+      @spamtrap_crypto_key ||= OpenSSL::KDF.hkdf(
+        Rails.application.secret_key_base,
+        salt:   'spamtrap-mutation',
+        info:   '',
+        length: KEY_LEN,
+        hash:   'SHA256'
+      )
+    end
+
+    def spamtrap_encrypt_field(field_name, salt_bytes)
+      cipher = OpenSSL::Cipher.new(CIPHER)
+      cipher.encrypt
+      cipher.key = spamtrap_crypto_key
+      cipher.iv  = salt_bytes
+      ct = cipher.update(field_name.to_s) + cipher.final
+      Base64.urlsafe_encode64(ct + cipher.auth_tag(TAG_LEN), padding: false)
+    end
+
+    def spamtrap_decrypt_field(token, salt_bytes)
+      raw = Base64.urlsafe_decode64(token)
+      return nil if raw.bytesize <= TAG_LEN
+      ct  = raw[0, raw.bytesize - TAG_LEN]
+      tag = raw[-TAG_LEN..]
+      cipher = OpenSSL::Cipher.new(CIPHER)
+      cipher.decrypt
+      cipher.key      = spamtrap_crypto_key
+      cipher.iv       = salt_bytes
+      cipher.auth_tag = tag
+      (cipher.update(ct) + cipher.final).to_sym
+    rescue OpenSSL::Cipher::CipherError, ArgumentError
+      nil
+    end
+  end
+end

data/lib/spamtrap/helper.rb

@@ -1,17 +1,68 @@
+module Spamtrap
+  module FormBuilderMutation
+    include Spamtrap::Crypto
+
+    MUTABLE_FIELDS = %i[
+      text_field email_field password_field number_field url_field telephone_field
+      text_area check_box hidden_field file_field date_field time_field
+      datetime_local_field month_field week_field search_field color_field
+      range_field select collection_select grouped_collection_select label
+    ].freeze
+
+    MUTABLE_FIELDS.each do |m|
+      define_method(m) do |field, *args, &blk|
+        field = spamtrap_encrypt_field(field.to_s, @spamtrap_salt) if @spamtrap_salt
+        super(field, *args, &blk)
+      end
+    end
+
+    def initialize(object_name, object, template, options)
+      super
+      @spamtrap_salt = options[:spamtrap_salt] if options[:spamtrap_salt]
+    end
+
+    def fields_for(record_name, record_object = nil, fields_options = {}, &block)
+      if @spamtrap_salt
+        if record_object.is_a?(Hash) && record_object.extractable_options?
+          record_object = record_object.merge(spamtrap_salt: @spamtrap_salt)
+        else
+          fields_options = fields_options.merge(spamtrap_salt: @spamtrap_salt)
+        end
+      end
+      super(record_name, record_object, fields_options, &block)
+    end
+  end
+end
+
 class ActionView::Helpers::FormBuilder
-  def spamtrap(parameter='spamtrap', options={})
-    options.reverse_merge!({:class => 'spamtrap'})
-    @template.text_area_tag(parameter, nil, options)
+  prepend Spamtrap::FormBuilderMutation
+
+  def spamtrap(parameter = 'spamtrap', options = {})
+    mutate = options.key?(:mutate) ? options.delete(:mutate) : Spamtrap.mutate
+    nonce  = options.key?(:nonce)  ? options.delete(:nonce)  : Spamtrap.nonce
+    options.reverse_merge!(class: 'spamtrap')
+
+    if mutate
+      @spamtrap_salt = SecureRandom.bytes(Spamtrap::Crypto::NONCE_LEN)
+      salt_field = @template.hidden_field_tag(
+        :spamtrap_mutation_salt, @spamtrap_salt.unpack1('H*')
+      )
+    end
+
+    @template.text_area_tag(parameter, nil, options) +
+      (nonce ? spamtrap_nonce_fields : ''.html_safe) +
+      (salt_field || ''.html_safe)
   end
 
-  # # def nonce(method, tag_value, options = {})
-  # def cryptographic_nonce(options = {})
-  #   # @template.hidden_field(@object_name, method, tag_value, objectify_options(options))
-  #   now, random = Time.now.to_i, SecureRandom.hex
-  #   # OpenSSL::HMAC.hexdigest()
-  #   cryptographic_nonce = Digest::MD5.hexdigest([timestamp, Rails.application.config.secret_key_base].join(':'))
-  #   @template.hidden_field(@object_name, :timestamp, now, objectify_options(options)) +
-  #   @template.hidden_field(@object_name, :random, random, objectify_options(options)) +
-  #   @template.hidden_field(@object_name, :spinner, cryptographic_nonce(now), objectify_options(options))
-  # end
+  private
+
+  def spamtrap_nonce_fields
+    timestamp = Time.now.to_i
+    ip        = @template.request.remote_ip
+    secret    = Rails.application.secret_key_base
+    nonce     = OpenSSL::HMAC.hexdigest('SHA256', secret, "#{timestamp}:#{ip}")
+
+    @template.hidden_field_tag(:spamtrap_timestamp, timestamp) +
+      @template.hidden_field_tag(:spamtrap_nonce, nonce)
+  end
 end

data/lib/spamtrap/version.rb

@@ -1,5 +1,5 @@
 module Spamtrap
 
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 
 end

data/lib/spamtrap.rb

@@ -1,4 +1,23 @@
+require 'openssl'
+
 module Spamtrap
+  class << self
+    attr_writer :nonce, :nonce_timeout, :mutate
+
+    def nonce
+      @nonce || false
+    end
+
+    def nonce_timeout
+      @nonce_timeout || 1800
+    end
+
+    def mutate
+      @mutate || false
+    end
+  end
+
+  require 'spamtrap/crypto'
   require 'spamtrap/controller'
   require 'spamtrap/helper'
 end

data/test/controller_test.rb

@@ -1,10 +1,347 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class ControllerTest < Minitest::Test
+# Test controllers — render a body so we can distinguish a real response
+# from a spamtrap-blocked one (which uses head 200 and has an empty body).
 
-  def test_foobar
-    assert true
-    assert_equal "hello", "hello"
+class HoneypotController < ActionController::Base
+  spamtrap :trap_field, only: :create
+
+  def create
+    render plain: 'success'
+  end
+end
+
+class NonceController < ActionController::Base
+  spamtrap :trap_field, nonce: true, only: :create
+
+  def create
+    render plain: 'success'
+  end
+end
+
+class NonceTimeoutController < ActionController::Base
+  spamtrap :trap_field, nonce: true, nonce_timeout: 60, only: :create
+
+  def create
+    render plain: 'success'
+  end
+end
+
+class MutationController < ActionController::Base
+  spamtrap :trap_field, mutate: true, only: :create
+
+  def create
+    # Render the remapped comment param keys so tests can assert on them
+    render plain: params[:comment].to_unsafe_h.keys.sort.join(',')
+  end
+end
+
+class NestedMutationController < ActionController::Base
+  spamtrap :trap_field, mutate: true, only: :create
+
+  def create
+    # Render top-level and nested address keys to verify salt propagation
+    comment_keys = params[:comment].to_unsafe_h.except('address').keys.sort
+    address_keys = params.dig(:comment, :address).to_unsafe_h.keys.sort rescue []
+    render plain: "#{comment_keys.join(',')};#{address_keys.join(',')}"
+  end
+end
+
+module NonceTestHelper
+  REMOTE_IP = '0.0.0.0'
+
+  def generate_nonce(timestamp, ip = REMOTE_IP)
+    secret = Rails.application.secret_key_base
+    OpenSSL::HMAC.hexdigest('SHA256', secret, "#{timestamp}:#{ip}")
+  end
+end
+
+module MutationTestHelper
+  include Spamtrap::Crypto
+
+  MUTATION_SALT     = SecureRandom.bytes(Spamtrap::Crypto::NONCE_LEN)
+  MUTATION_SALT_HEX = MUTATION_SALT.unpack1('H*')
+end
+
+class HoneypotControllerTest < ActionController::TestCase
+  tests HoneypotController
+
+  def test_empty_honeypot_allows_request
+    post :create, params: { trap_field: '' }
+    assert_response :ok
+    assert_equal 'success', response.body
+  end
+
+  def test_filled_honeypot_silently_discards
+    post :create, params: { trap_field: 'buy cheap meds' }
+    assert_response :ok
+    assert_empty response.body
+  end
+end
+
+class NonceControllerTest < ActionController::TestCase
+  include NonceTestHelper
+  tests NonceController
+
+  def test_valid_nonce_allows_request
+    timestamp = Time.now.to_i
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp)
+    }
+    assert_response :ok
+    assert_equal 'success', response.body
+  end
+
+  def test_tampered_nonce_is_rejected
+    timestamp = Time.now.to_i
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: 'deadbeef'
+    }
+    assert_response :ok
+    assert_empty response.body
+  end
+
+  def test_expired_nonce_is_rejected
+    timestamp = Time.now.to_i - 7200
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp)
+    }
+    assert_response :ok
+    assert_empty response.body
+  end
+
+  def test_missing_nonce_fields_are_rejected
+    post :create, params: { trap_field: '' }
+    assert_response :ok
+    assert_empty response.body
+  end
+
+  def test_filled_honeypot_takes_priority_over_valid_nonce
+    timestamp = Time.now.to_i
+    post :create, params: {
+      trap_field: 'spam',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp)
+    }
+    assert_response :ok
+    assert_empty response.body
+  end
+end
+
+class NonceTimeoutControllerTest < ActionController::TestCase
+  include NonceTestHelper
+  tests NonceTimeoutController
+
+  def test_nonce_within_custom_timeout_passes
+    timestamp = Time.now.to_i - 30
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp)
+    }
+    assert_response :ok
+    assert_equal 'success', response.body
+  end
+
+  def test_nonce_beyond_custom_timeout_is_rejected
+    timestamp = Time.now.to_i - 120
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp)
+    }
+    assert_response :ok
+    assert_empty response.body
+  end
+end
+
+class MutationControllerTest < ActionController::TestCase
+  include MutationTestHelper
+  tests MutationController
+
+  def test_encrypted_field_names_are_remapped_to_real_names
+    body_token  = spamtrap_encrypt_field('body',  MUTATION_SALT)
+    email_token = spamtrap_encrypt_field('email', MUTATION_SALT)
+
+    post :create, params: {
+      trap_field: '',
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { body_token => 'Hello world', email_token => 'test@example.com' }
+    }
+
+    assert_response :ok
+    assert_equal 'body,email', response.body
+  end
+
+  def test_unencrypted_field_names_pass_through_unchanged
+    post :create, params: {
+      trap_field: '',
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { body: 'Hello', email: 'test@example.com' }
+    }
+
+    assert_response :ok
+    assert_equal 'body,email', response.body
+  end
+
+  def test_no_salt_leaves_encrypted_params_unmapped
+    body_token = spamtrap_encrypt_field('body', MUTATION_SALT)
+
+    post :create, params: {
+      trap_field: '',
+      comment: { body_token => 'Hello' }
+    }
+
+    assert_response :ok
+    refute_equal 'body', response.body
+  end
+
+  def test_wrong_salt_fails_to_decrypt
+    other_salt     = SecureRandom.bytes(Spamtrap::Crypto::NONCE_LEN)
+    body_token     = spamtrap_encrypt_field('body', other_salt)
+
+    post :create, params: {
+      trap_field: '',
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { body_token => 'Hello' }
+    }
+
+    assert_response :ok
+    refute_equal 'body', response.body
+  end
+end
+
+class NestedMutationControllerTest < ActionController::TestCase
+  include MutationTestHelper
+  tests NestedMutationController
+
+  def test_salt_propagates_to_fields_for_child_builder
+    body_token    = spamtrap_encrypt_field('body',    MUTATION_SALT)
+    street_token  = spamtrap_encrypt_field('street',  MUTATION_SALT)
+    city_token    = spamtrap_encrypt_field('city',    MUTATION_SALT)
+
+    post :create, params: {
+      trap_field: '',
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: {
+        body_token => 'Hello',
+        address: {
+          street_token => '123 Main St',
+          city_token   => 'Springfield'
+        }
+      }
+    }
+
+    assert_response :ok
+    assert_equal 'body;city,street', response.body
+  end
+end
+
+# Controller that relies entirely on global defaults (no per-call options).
+class GlobalDefaultsController < ActionController::Base
+  spamtrap :trap_field, only: :create
+
+  def create
+    render plain: params[:comment].to_unsafe_h.keys.sort.join(',')
   end
+end
+
+# Controller that explicitly overrides global defaults with false.
+class GlobalOverrideController < ActionController::Base
+  spamtrap :trap_field, nonce: false, mutate: false, only: :create
 
+  def create
+    render plain: params[:comment].to_unsafe_h.keys.sort.join(',')
+  end
+end
+
+class GlobalDefaultsControllerTest < ActionController::TestCase
+  include MutationTestHelper
+  include NonceTestHelper
+  tests GlobalDefaultsController
+
+  setup do
+    Spamtrap.nonce  = true
+    Spamtrap.mutate = true
+  end
+
+  teardown do
+    Spamtrap.nonce  = false
+    Spamtrap.mutate = false
+  end
+
+  def test_global_nonce_default_rejects_missing_nonce
+    post :create, params: { trap_field: '', comment: { body: 'Hello' } }
+    assert_response :ok
+    assert_empty response.body
+  end
+
+  def test_global_nonce_default_accepts_valid_nonce
+    timestamp = Time.now.to_i
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp),
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { spamtrap_encrypt_field('body', MUTATION_SALT) => 'Hello' }
+    }
+    assert_response :ok
+    assert_equal 'body', response.body
+  end
+
+  def test_global_mutate_default_remaps_encrypted_fields
+    body_token = spamtrap_encrypt_field('body', MUTATION_SALT)
+    timestamp  = Time.now.to_i
+    post :create, params: {
+      trap_field: '',
+      spamtrap_timestamp: timestamp,
+      spamtrap_nonce: generate_nonce(timestamp),
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { body_token => 'Hello' }
+    }
+    assert_response :ok
+    assert_equal 'body', response.body
+  end
+end
+
+class GlobalOverrideControllerTest < ActionController::TestCase
+  include MutationTestHelper
+  tests GlobalOverrideController
+
+  setup do
+    Spamtrap.nonce  = true
+    Spamtrap.mutate = true
+  end
+
+  teardown do
+    Spamtrap.nonce  = false
+    Spamtrap.mutate = false
+  end
+
+  def test_per_call_false_overrides_global_nonce
+    # No nonce params — would fail if global nonce: true were in effect
+    post :create, params: {
+      trap_field: '',
+      comment: { body: 'Hello' }
+    }
+    assert_response :ok
+    assert_equal 'body', response.body
+  end
+
+  def test_per_call_false_overrides_global_mutate
+    # Plain field name — would be remapped if global mutate: true were in effect
+    post :create, params: {
+      trap_field: '',
+      spamtrap_mutation_salt: MUTATION_SALT_HEX,
+      comment: { body: 'Hello' }
+    }
+    assert_response :ok
+    assert_equal 'body', response.body
+  end
 end

data/test/test_helper.rb

@@ -1,4 +1,30 @@
 require 'rubygems'
+require 'rails'
 require 'action_controller'
+require 'action_controller/test_case'
 require 'minitest/autorun'
 require 'spamtrap'
+
+class SpamtrapTestApp < Rails::Application
+  config.secret_key_base = 'a' * 64
+  config.eager_load = false
+  config.logger = Logger.new(nil)
+end
+
+Rails.application.initialize!
+
+Rails.application.routes.draw do
+  post 'honeypot/create',      to: 'honeypot#create'
+  post 'nonce/create',         to: 'nonce#create'
+  post 'nonce_timeout/create', to: 'nonce_timeout#create'
+  post 'mutation/create',      to: 'mutation#create'
+  post 'nested_mutation/create',  to: 'nested_mutation#create'
+  post 'global_defaults/create',  to: 'global_defaults#create'
+  post 'global_override/create',  to: 'global_override#create'
+end
+
+class ActionController::TestCase
+  setup do
+    @routes = Rails.application.routes
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spamtrap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Cedric Howe
@@ -32,6 +32,7 @@ extra_rdoc_files: []
 files:
 - lib/spamtrap.rb
 - lib/spamtrap/controller.rb
+- lib/spamtrap/crypto.rb
 - lib/spamtrap/helper.rb
 - lib/spamtrap/version.rb
 - test/controller_test.rb
@@ -54,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Simple spamtrap for spambots.
 test_files: