<form method="POST">
    <h3>Editing: EncryptCookies.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Cookie\Middleware;

use Closure;
use Illuminate\Contracts\Encryption\DecryptException;
use Illuminate\Contracts\Encryption\Encrypter as EncrypterContract;
use Illuminate\Cookie\CookieValuePrefix;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

class EncryptCookies
{
    /**
     * The encrypter instance.
     *
     * @var \Illuminate\Contracts\Encryption\Encrypter
     */
    protected $encrypter;

    /**
     * The names of the cookies that should not be encrypted.
     *
     * @var array
     */
    protected $except = [];

    /**
     * Indicates if cookies should be serialized.
     *
     * @var bool
     */
    protected static $serialize = false;

    /**
     * Create a new CookieGuard instance.
     *
     * @param  \Illuminate\Contracts\Encryption\Encrypter  $encrypter
     * @return void
     */
    public function __construct(EncrypterContract $encrypter)
    {
        $this-&gt;encrypter = $encrypter;
    }

    /**
     * Disable encryption for the given cookie name(s).
     *
     * @param  string|array  $name
     * @return void
     */
    public function disableFor($name)
    {
        $this-&gt;except = array_merge($this-&gt;except, (array) $name);
    }

    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function handle($request, Closure $next)
    {
        return $this-&gt;encrypt($next($this-&gt;decrypt($request)));
    }

    /**
     * Decrypt the cookies on the request.
     *
     * @param  \Symfony\Component\HttpFoundation\Request  $request
     * @return \Symfony\Component\HttpFoundation\Request
     */
    protected function decrypt(Request $request)
    {
        foreach ($request-&gt;cookies as $key =&gt; $cookie) {
            if ($this-&gt;isDisabled($key) || is_array($cookie)) {
                continue;
            }

            try {
                $value = $this-&gt;decryptCookie($key, $cookie);

                $hasValidPrefix = strpos($value, CookieValuePrefix::create($key, $this-&gt;encrypter-&gt;getKey())) === 0;

                $request-&gt;cookies-&gt;set(
                    $key, $hasValidPrefix ? CookieValuePrefix::remove($value) : null
                );
            } catch (DecryptException $e) {
                $request-&gt;cookies-&gt;set($key, null);
            }
        }

        return $request;
    }

    /**
     * Decrypt the given cookie and return the value.
     *
     * @param  string  $name
     * @param  string|array  $cookie
     * @return string|array
     */
    protected function decryptCookie($name, $cookie)
    {
        return is_array($cookie)
                        ? $this-&gt;decryptArray($cookie)
                        : $this-&gt;encrypter-&gt;decrypt($cookie, static::serialized($name));
    }

    /**
     * Decrypt an array based cookie.
     *
     * @param  array  $cookie
     * @return array
     */
    protected function decryptArray(array $cookie)
    {
        $decrypted = [];

        foreach ($cookie as $key =&gt; $value) {
            if (is_string($value)) {
                $decrypted[$key] = $this-&gt;encrypter-&gt;decrypt($value, static::serialized($key));
            }
        }

        return $decrypted;
    }

    /**
     * Encrypt the cookies on an outgoing response.
     *
     * @param  \Symfony\Component\HttpFoundation\Response  $response
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function encrypt(Response $response)
    {
        foreach ($response-&gt;headers-&gt;getCookies() as $cookie) {
            if ($this-&gt;isDisabled($cookie-&gt;getName())) {
                continue;
            }

            $response-&gt;headers-&gt;setCookie($this-&gt;duplicate(
                $cookie,
                $this-&gt;encrypter-&gt;encrypt(
                    CookieValuePrefix::create($cookie-&gt;getName(), $this-&gt;encrypter-&gt;getKey()).$cookie-&gt;getValue(),
                    static::serialized($cookie-&gt;getName())
                )
            ));
        }

        return $response;
    }

    /**
     * Duplicate a cookie with a new value.
     *
     * @param  \Symfony\Component\HttpFoundation\Cookie  $cookie
     * @param  mixed  $value
     * @return \Symfony\Component\HttpFoundation\Cookie
     */
    protected function duplicate(Cookie $cookie, $value)
    {
        return new Cookie(
            $cookie-&gt;getName(), $value, $cookie-&gt;getExpiresTime(),
            $cookie-&gt;getPath(), $cookie-&gt;getDomain(), $cookie-&gt;isSecure(),
            $cookie-&gt;isHttpOnly(), $cookie-&gt;isRaw(), $cookie-&gt;getSameSite()
        );
    }

    /**
     * Determine whether encryption has been disabled for the given cookie.
     *
     * @param  string  $name
     * @return bool
     */
    public function isDisabled($name)
    {
        return in_array($name, $this-&gt;except);
    }

    /**
     * Determine if the cookie contents should be serialized.
     *
     * @param  string  $name
     * @return bool
     */
    public static function serialized($name)
    {
        return static::$serialize;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>