Nivel inicial8 min de lectura · Publicado el

Strong params en Ruby on Rails: strong parameters y expect

Strong params en Rails: en un formulario con name y age alguien añade role=administrator a boli, y la lista de permitidos lo descarta Params: solo lo permitidorubentejera.com nameagerole=administratorpermitidosnameagerole
El formulario esperaba name y age, pero alguien añadió a boli role=administrator. Como role no está en la lista de permitidos (params.expect en Rails 8), se descarta y solo pasan name y age.

Si en un controlador escribes esto, Rails se niega a ejecutarlo:

@article = Article.new(params[:article])
# ActiveModel::ForbiddenAttributesError

¿Por qué? Porque desde el navegador pueden mandarte cualquier campo, no solo los que aparecen en tu formulario.

El problema: la asignación masiva

Imagina un modelo Usuario con los atributos name, age y role, donde role puede ser user o administrator. Tu formulario de registro solo muestra el nombre y la edad.

Si aceptaras params[:usuario] entero, alguien podría añadir a mano el campo role=administrator a la petición. Se guardaría, y esa persona se convertiría en administradora del sistema. A este ataque se le llama asignación masiva (mass assignment).

Es como un formulario de inscripción en papel: tú esperas nombre y edad, pero alguien añade a boli una línea que dice «y además, soy el director». Si lo archivas sin mirar, ya lo es.

Los strong parameters son la lista de campos que tú permites. Todo lo demás se descarta.

Cómo se usan los strong parameters en Rails

Opción 1: asignar campo a campo

Funciona, pero se vuelve pesado en cuanto el modelo crece:

@article = Article.new(title: params[:article][:title],
                       body: params[:article][:body])

Opción 2: un método privado con los campos permitidos

Es la forma habitual. En Rails 8 se usa expect:

class ArticlesController < ApplicationController
  def create
    @article = Article.new(article_params)
    # …
  end

  private

  def article_params
    params.expect(article: [:title, :body])
  end
end

Si la petición trae article[admin]=true, ese campo se descarta y solo pasan title y body.

En Rails 7 y anteriores se escribe con require y permit, que sigue funcionando en Rails 8:

def article_params
  params.require(:article).permit(:title, :body)
end
require(…).permit(…) expect(…)
Disponible desde Rails 4 Rails 8.0
Si falta la clave article Error 400 (ParameterMissing) Error 400 (ParameterMissing)
Si article llega como texto en vez de como hash Error 500 (NoMethodError) Error 400 (ParameterMissing)

La diferencia está en la última fila: si alguien manipula la petición, expect responde con un error de petición incorrecta en lugar de un fallo del servidor.

Lo que no está en la lista, no entra.

Compruébalo con un test

La lista de permitidos es una regla de seguridad, así que merece un test que diga qué debe pasar y qué no. No hace falta levantar el controlador entero: ActionController::Parameters se puede crear a mano y probar como cualquier objeto. Este test usa Minitest y solo necesita la gema actionpack, la parte de Rails que incluye los controladores. Si no tienes un proyecto de Rails a mano, instálala sola:

gem install actionpack -v 8.1.4.1

Y guarda el test en usuario_params_test.rb:

require "minitest/autorun"
require "action_controller"

# Lo mismo que hace el método privado del controlador, sin el controlador
def usuario_params(params)
  params.expect(usuario: [:name, :age])
end

class UsuarioParamsTest < Minitest::Test
  def test_descarta_el_rol_que_no_esta_en_la_lista
    params = ActionController::Parameters.new(
      usuario: { name: "Ana", age: "30", role: "administrator" }
    )

    permitidos = usuario_params(params)

    assert_equal({ "name" => "Ana", "age" => "30" }, permitidos.to_h)
    refute permitidos.key?(:role)
  end

  def test_sin_la_clave_usuario_es_una_peticion_incorrecta
    params = ActionController::Parameters.new(name: "Ana")

    assert_raises(ActionController::ParameterMissing) { usuario_params(params) }
  end
end
ruby usuario_params_test.rb
2 runs, 3 assertions, 0 failures, 0 errors, 0 skips

El primer test es el ataque del formulario en papel: llega role=administrator y no pasa. Si un día alguien añade :role a la lista para «arreglar» otra pantalla, este test se pone en rojo y obliga a pensarlo dos veces. Vale igual si el cambio lo propone un asistente de IA: el test no sabe quién escribió el código, solo si cumple la regla. En una aplicación completa, el mismo método se prueba también con un test de integración del controlador, que comprueba la respuesta 400.

Errores frecuentes

Todos estos ejemplos parten de la misma petición, con un texto, una lista, un objeto anidado y una lista de objetos:

datos = { article: { title: "Hola",
                     tags: ["ruby", "rails"],
                     address: { city: "Las Palmas" },
                     comments: [{ body: "Bien" }, { body: "Genial" }] } }
params = ActionController::Parameters.new(datos)

1. Permitir una lista o un objeto como si fuera un campo simple. :tags solo deja pasar un valor suelto (un texto, un número…). Si llega una lista, se descarta sin avisar:

params.expect(article: [:title, :tags]).to_h
# => {"title" => "Hola"}

params.expect(article: [:title, tags: []]).to_h
# => {"title" => "Hola", "tags" => ["ruby", "rails"]}

Con el objeto anidado pasa lo mismo: :address lo descarta y address: [:city] lo deja pasar.

2. Olvidar el doble corchete en una lista de objetos con expect. Para una lista de comentarios, expect pide [[ ]]. Con un solo corchete, los comentarios desaparecen:

params.expect(article: [:title, comments: [:body]]).to_h
# => {"title" => "Hola"}

params.expect(article: [:title, comments: [[:body]]]).to_h
# => {"title" => "Hola", "comments" => [{"body" => "Bien"}, {"body" => "Genial"}]}

Es a propósito: el doble corchete dice «aquí espero una lista», y así expect rechaza un objeto suelto donde debía haber una lista. Con permit, en cambio, comments: [:body] sí acepta la lista. El doble corchete también acepta el hash con índices ({"0" => {…}, "1" => {…}}) que envían los formularios con fields_for y accepts_nested_attributes_for; con un solo corchete, expect lo deja vacío. Si migras de permit a expect, revisa estos casos uno a uno.

3. Usar permit! para salir del paso. permit! marca todo como permitido, incluido el role del ataque:

ActionController::Parameters.new(article: { title: "x", role: "administrator" })
  .require(:article).permit!.to_h
# => {"title" => "x", "role" => "administrator"}

La guía oficial pide «extremo cuidado» con él (traducción nuestra), porque deja asignar todos los atributos del modelo, también los que añadas en el futuro.

4. No enterarte de que un campo se ha descartado. Si olvidas un campo en la lista, no hay error: el formulario «no guarda» y no sabes por qué. Rails puede avisarte con la opción action_on_unpermitted_parameters, que por defecto vale :log en desarrollo y en test (lo apunta en el log) y false en producción. Con :raise, lanza una excepción:

# config/environments/test.rb
config.action_controller.action_on_unpermitted_parameters = :raise
ActionController::UnpermittedParameters: found unpermitted parameter: :role

Ojo: este aviso solo salta con permit, se use con require o sin él. Con expect, el campo se descarta igual, pero sin aviso ni excepción. Es así por diseño: se planteó en la incidencia #53091 de Rails, que se cerró como «not planned» (no previsto). Se ha comprobado ejecutándolo con Rails 8.1.4.1 y en el código de actionpack, tanto en esa versión como en la rama principal de Rails, donde expect filtra sin pasar esa opción. Si dependes de :raise para detectar campos olvidados, tenlo en cuenta o cúbrelo con un test como el de arriba.

Cuándo no bastan los strong params

Los strong params responden a una sola pregunta: qué campos pueden llegar al modelo. Hay dos que no responden:

  • ¿El valor es correcto? Una edad de -5 es un campo permitido, así que pasa. Comprobar los valores es trabajo de las validaciones de Active Record.
  • ¿Esta persona puede cambiarlo? Si un administrador sí puede cambiar el role y un usuario normal no, no basta con una lista. Hacen falta dos métodos con listas distintas y que el controlador elija según quién hace la petición. Decidir quién puede hacer qué es la autorización, y va aparte.

Ejercicio de cinco minutos

  1. Copia el test de usuario_params y añade un campo hobbies que llegue como lista (["leer", "correr"]). Escribe primero el test que espera recibirla y comprueba que falla.
  2. Haz que pase cambiando solo la lista de permitidos.
  3. Añade una lista de direcciones (addresses: [{ city: "…" }]) y comprueba qué pasa con uno y con dos corchetes.

Sigue leyendo

Fuentes

  • Action Controller Overview: Strong Parameters, guía oficial de Rails 8.1, y la API de ActionController::Parameters.
  • Configuring Rails Applications, guía oficial de Rails 8.1: action_on_unpermitted_parameters (:log en desarrollo y test, false en el resto; :raise lanza ActionController::UnpermittedParameters).
  • El comportamiento de expect con el doble corchete y con action_on_unpermitted_parameters se ha comprobado también en el código de ActionController::Parameters de actionpack 8.1.4.1 y de la rama main de Rails (actionpack/lib/action_controller/metal/strong_parameters.rb), y en la incidencia #53091 (cerrada como «not planned» el 29 de septiembre de 2024): expect no lanza UnpermittedParameters.
  • Ejecutado en noviembre de 2026 con Ruby 4.0.9 y Rails 8.1.4.1: el ForbiddenAttributesError, permit y expect descartando un campo admin, los errores de la tabla y un test de integración de un controlador con expect (400 cuando falta la clave). El test de usuario_params y los errores frecuentes se han ejecutado el 11 de noviembre de 2026 con Ruby 4.0.9, actionpack 8.1.4.1 y Minitest 6.0.0 (imagen oficial ruby:4.0 de Docker).