yiisoft / csrf

PSR-15 middleware implementing CSRF protection

Yii CSRF Protection Library

The package provides PSR-15 middleware for CSRF protection:

• It supports two algorithms out of the box:
  • Synchronizer CSRF token with customizable token generation and storage. By default, it uses random data and session.
  • HMAC based token with customizable identity generation. Uses session by default.
• It has ability to apply masking to CSRF token string to make BREACH attack impossible.

Requirements

• PHP 7.4 or higher.

Installation

The package could be installed with Composer:

composer require yiisoft/csrf

General usage

In order to enable CSRF protection you need to add CsrfMiddleware to your main middleware stack. In Yii it is done by configuring config/web/application.php:

return [
    Yiisoft\Yii\Http\Application::class => [
        '__construct()' => [
            'dispatcher' => DynamicReference::to(static function (Injector $injector) {
                return ($injector->make(MiddlewareDispatcher::class))
                    ->withMiddlewares(
                        [
                            ErrorCatcher::class,
                            SessionMiddleware::class,
                            CsrfMiddleware::class, // <-- add this
                            Router::class,
                        ]
                    );
            }),
        ],
    ],
];

By default, CSRF token is obtained from _csrf request body parameter or X-CSRF-Token header.

You can access currently valid token as a string using CsrfTokenInterface:

/** @var Yiisoft\Csrf\CsrfTokenInterface $csrfToken */
$csrf = $csrfToken->getValue();

If the token does not pass validation, the response 422 Unprocessable Entity will be returned. You can change this behavior by implementing your own request handler:

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Csrf\CsrfMiddleware;

/**
 * @var Psr\Http\Message\ResponseFactoryInterface $responseFactory
 * @var Yiisoft\Csrf\CsrfTokenInterface $csrfToken
 */
 
$failureHandler = new class ($responseFactory) implements RequestHandlerInterface {
    private ResponseFactoryInterface $responseFactory;
    
    public function __construct(ResponseFactoryInterface $responseFactory)
    {
        $this->responseFactory = $responseFactory;
    }

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $response = $this->responseFactory->createResponse(400);
        $response
            ->getBody()
            ->write('Bad request.');
        return $response;
    }
};

$middleware = new CsrfMiddleware($responseFactory, $csrfToken, $failureHandler);

CSRF Tokens

In case Yii framework is used along with config plugin, the package is configured automatically to use synchronizer token and masked decorator. You can change that depending on your needs.

Synchronizer CSRF token

Synchronizer CSRF token is a stateful CSRF token that is a unique random string. It is saved in persistent storage available only to the currently logged-in user. The same token is added to a form. When the form is submitted, token that came from the form is compared against the token stored.

SynchronizerCsrfToken requires implementation of the following interfaces:

• CsrfTokenGeneratorInterface for generating a new CSRF token;
• CsrfTokenStorageInterface for persisting a token between requests.

Package provides RandomCsrfTokenGenerator that generates a random token and SessionCsrfTokenStorage that persists a token between requests in a user session.

To learn more about the synchronizer token pattern, check OWASP CSRF cheat sheet.

HMAC based token

HMAC based token is a stateless CSRF token that does not require any storage. The token is a hash from session ID and a timestamp used to prevent replay attacks. The token is added to a form. When the form is submitted, we re-generate the token from the current session ID and a timestamp from the original token. If two hashes match, we check that the timestamp is less than the token lifetime.

HmacCsrfToken requires implementation of CsrfTokenIdentityGeneratorInterface for generating an identity. The package provides SessionCsrfTokenIdentityGenerator that is using session ID thus making the session a token scope.

Parameters set via the HmacCsrfToken constructor are:

• $secretKey — shared secret key used to generate the hash;
• $algorithm — hash algorithm for message authentication. sha256, sha384 or sha512 are recommended;
• $lifetime — number of seconds that the token is valid for.

To learn more about HMAC based token pattern check OWASP CSRF cheat sheet.

Stub CSRF token

The StubCsrfToken simply stores and returns a token string. It does not perform any additional validation. This implementation can be useful when mocking CSRF token behavior during unit testing or when providing placeholder functionality in temporary solutions.

Masked CSRF token

MaskedCsrfToken is a decorator for CsrfTokenInterface that applies masking to a token string. It makes BREACH attack impossible, so it is safe to use token in HTML to be later passed to the next request either as a hidden form field or via JavaScript async request.

It is recommended to always use this decorator.

Documentation

• Internals

If you need help or have a question, the Yii Forum is a good place for that. You may also check out other Yii Community Resources.

License

The Yii CSRF Protection Library is free software. It is released under the terms of the BSD License. Please see LICENSE for more information.

Maintained by Yii Software.

Support the project

Follow updates

csrf's Issues

Need Provider for Yii app

For use this implementation CSRF in yii app need provider for make CsrfToken::initialize() as here.

Suggestion:

1. Rewrite SessionCsrfTokenStorage.php to NativeSessionCsrfTokenStorage with use $_SESSION.

2. Create new package yiisoft/yii-csrf with:

• Config providers.php.
• Provider for initialize CsrfToken.
• Implementation CsrfTokenStorageInterface with use yii sessions.

Replace yiisoft/yii-web dependency with yiisoft/session

yiisoft/yii-web dependency needs to be replaced with yiisoft/session after yiisoft/session will be separated from yiisoft/yii-web (yiisoft/yii-web#288)

Add support of `psr/http-message` version 2.0

Add Custom Request Headers for AJAX/API

https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#employing-custom-request-headers-for-ajaxapi

Remove `psalm83.xml` after raising PHP version to `8.3`

Separate token generation and token checking

Why generate a token here: ?

csrf/src/CsrfMiddleware.php

Lines 67 to 76 in 5f442d4

	private function getToken(): string
	{
	$token = $this->storage->get();
	if (empty($token)) {
	$token = Random::string();
	$this->storage->set($token);
	}
	return $token;
	}

If you can generate here:

csrf/src/CsrfToken.php

Lines 25 to 33 in 5f442d4

	public function getValue(): string
	{
	$token = $this->storage->get();
	if (empty($token)) {
	throw new LogicException('CSRF token is not defined.');
	}
	return TokenMask::apply($token);
	}
	}

In this case, the token will be generated on the first use, not on the first request.

Add ability to exclude / include URLs from CSRF protection

Usually the middleware is enabled globally. Need to add a way to exclude certain URLs or include only certain URL.

Readme docs

Readme should contain docs.

Add lifetime to synchronizer token

Whether the package needs to be updated according to OWASP?

In the documentation you refer to OWASP: now only Synchronizer Token Pattern and Double Submit Cookie are actual there. HMAC Based Token Pattern and Encryption based Token Pattern were removed.

It should be understood that the Double Submit Cookie will require the configuration to use Yiisoft\Cookies\CookieMiddleware.

But maybe you shouldn't add the Double Submit Cookie pattern, because it seems to me that this thing is for rare use.

Steps to update:

1) To remove HMAC Based Token Pattern
2) To add Double Submit Cookie processing logic to the middleware (optional)
3) To write something like DoubleSubmitCsrfToken (optional)
4) To update the documentation

Draft with the Double Submit Cookie pattern :

final class CsrfMiddleware implements MiddlewareInterface
{
...

private bool $sendCookie = false;

...

public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
    if ($this->token instanceof DoubleSubmitCsrfToken) {
        $cookieValues = $request->getCookieParams();
        $cookieValue = $cookieValues[$this->parameterName] ?? null;
        
        // the setValue() method is needed to validate the value later, if necessary
        // for example, "return hash_equals($this->getValue(), $token);"
        $cookieValue ? $this->token->setValue($cookieValue) : $this->sendCookie = true;
    }

    if (!$this->validateCsrfToken($request)) {
        $response = $this->responseFactory->createResponse(Status::UNPROCESSABLE_ENTITY);
        $response->getBody()->write(Status::TEXTS[Status::UNPROCESSABLE_ENTITY]);
        return $response;
    }

    $response = $handler->handle($request);

    return $this->sendCookie ?
           $this->token->getCsrfCookie($this->parameterName)->addToResponse($response) :
           $response;
}

Why are checks made before the validateCsrfToken method? OWASP requires the cookie to be set the first time the user visits the site: "When a user visits (even before authenticating to prevent login CSRF), the site should generate a (cryptographically strong) pseudorandom value and set it as a cookie on the user's machine separate from the session identifier."

update links

What steps will reproduce the problem?

http=>https

Switch to stateless CSRF protection algorithm

We currently use syncronizer pattern from https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#synchronizer-token-pattern. It is stateful. Switching to any stateless pattern would make starting a session obsolete.

See #12