Dev.to Security 🔐 Cybersecurity 👁 0 📖 4 min read

One Form Field Made This User an Admin: Laravel Mass Assignment

The profile form has two fields: name and email. Add one more field to the request, is_admin=1, and the user is an admin. No password cracking and no SQL injection. This is mass assignment, and two lines of very common

The profile form has two fields: name and email. Add one more field to the request, is_admin=1, and the user is an admin.

No password cracking and no SQL injection. This is mass assignment, and two lines of very common Laravel code make it possible. Below I run the attack against a fresh Laravel 13.43 app (PHP 8.5, SQLite, on my own machine), then shut it down four different ways. Every output shown is real.

Video version:

The vulnerable code

// app/Models/Member.php
class Member extends Model
{
    protected $guarded = [];   // "I'm tired of maintaining $fillable"
}
// routes/web.php
Route::put('/profile', function (Request $request) {
    $user = Member::find(1);

    $user->update($request->all());

    return $user->only('id', 'name', 'email', 'is_admin');
});

The members table has name, email and is_admin (default false).

$guarded = [] turns off Eloquent's mass-assignment protection. $request->all() passes every field the client sent, not just the ones your form shows.

The attack

A normal request:

$ curl -X PUT localhost:8000/profile -d name=Ana -d email=[email protected]
{"id":1,"name":"Ana","email":"[email protected]","is_admin":0}

The same request with one extra field:

$ curl -X PUT localhost:8000/profile -d name=Ana -d email=[email protected] -d is_admin=1
{"id":1,"name":"Ana","email":"[email protected]","is_admin":"1"}

That's the whole attack. Anyone can add a field from the browser's dev tools, and CSRF protection doesn't help, because the request comes from the logged-in user's own session. (I turned CSRF off for this route only so the demo could use plain curl.)

This class of bug is old and famous. In 2012, a developer exploited mass assignment in Ruby on Rails to add his own key to the Rails organization on GitHub and push a commit. That incident is a big part of why frameworks like Laravel protect you by default. $guarded = [] throws that protection away.

Fix 1: allow-list the fields with #[Fillable]

Laravel 13 lets you declare fillable fields with a PHP attribute. The fresh User model in a new Laravel 13 app already uses it:

use Illuminate\Database\Eloquent\Attributes\Fillable;

#[Fillable(['name', 'email'])]
class Member extends Model
{
}

The classic protected $fillable = ['name', 'email']; still works too. Same attack, same curl:

{"id":1,"name":"Ana","email":"[email protected]","is_admin":0}

is_admin is silently dropped.

Fix 2: never pass $request->all()

$data = $request->validate([
    'name'  => 'required|string|max:100',
    'email' => 'required|email',
]);

$user->update($data);

validate() returns only the fields that have rules. A Form Request's validated() method does the same. I tested this fix on its own, with $guarded = [] still in the model, and the attack failed: is_admin stayed 0.

Use both Fix 1 and Fix 2. Then a single mistake (a new route that forgets validation, or a model someone unguards) doesn't open the door.

The trap: block-lists with #[Guarded]

A tempting middle ground is to guard only the dangerous columns:

#[Guarded(['is_admin'])]
class Member extends Model {}

It works today. Six months later someone adds a role column, and nobody remembers to update the guarded list. I added a role column and sent role=superadmin:

{"id":1,"name":"Ana","email":"[email protected]","is_admin":0,"role":"superadmin", …}

It went straight in. An allow-list fails safe: new columns stay closed until you deliberately open them.

Fix 3: make Laravel throw instead of silently ignoring

Silently dropping unknown fields is safe, but it can also hide bugs in your own code, like a field you meant to save. Turn on strict behavior outside production:

// app/Providers/AppServiceProvider.php
public function boot(): void
{
    Model::preventSilentlyDiscardingAttributes(! app()->isProduction());
}

Now, in local and test environments:

Member::find(1)->update(['name' => 'X', 'is_admin' => 1]);
// Illuminate\Database\Eloquent\MassAssignmentException:
// Add fillable property [is_admin] to allow mass assignment on [App\Models\Member].

Your test suite catches the mistake before production does. (Model::shouldBeStrict() turns this on together with lazy-loading prevention and missing-attribute checks.)

Fix 4: set sensitive fields explicitly, behind authorization

When an admin really does need to promote someone, don't route it through mass assignment at all:

Gate::authorize('promote', $member);

$member->is_admin = true;
$member->save();

Use Gate::authorize() here. Since Laravel 11, the base controller no longer includes the AuthorizesRequests trait, so $this->authorize() isn't there by default. If the gate says no, you get AuthorizationException: This action is unauthorized.

forceFill(['is_admin' => true]) also works, but it skips the fillable list entirely. Only pass values you control, never request data.

Recap

  • $guarded = [] + $request->all() = anyone can make themselves admin.
  • Allow-list with #[Fillable([...])] (or $fillable).
  • Save $request->validated(), never $request->all().
  • Avoid block-lists (#[Guarded]/$guarded): new columns become writable.
  • Model::preventSilentlyDiscardingAttributes() in dev and tests.
  • Set sensitive fields explicitly, behind a gate. Never forceFill() user input.

Now search your project for $guarded = []. Did you find one? 👀

I post one tested coding tip every day on YouTube at Refactorly. The 30-second version of this one is here.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.