Is there a patch available for CVE-2026-53639?

Yes, a patch is available for CVE-2026-53639. Update the affected software to the latest version immediately.

Sylius CVE-2026-53639

Q: What is the CVSS score of CVE-2026-53639?

CVE-2026-53639 has a CVSS 4.0 base score of 6.3 (Medium). CVSS vector: CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X. EPSS exploitation probability: 0.5%.

MEDIUM

Authorization Bypass Through User-Controlled Key (CWE-639)

2026-07-09 https://github.com/Sylius/Sylius

GHSA-mr9r-h354-966r

PHP Authentication Bypass

6.3

CVSS 4.0 · Vendor: https://github.com/Sylius/Sylius

Severity by source

Vendor (https://github.com/Sylius/Sylius) PRIMARY

6.3 MEDIUM

CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X

vuln.today AI

6.5 MEDIUM

Network-exploitable with no credentials but requires out-of-band UUID acquisition (AC:H); confidentiality high due to full order PII exposure, integrity low for redirect manipulation only, no availability impact.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N

4.0 AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/Sylius/Sylius).

CVSS VectorVendor: https://github.com/Sylius/Sylius

Attack Vector

Network

Attack Complexity

Low

Privileges Required

None

User Interaction

None

Scope

Lifecycle Timeline

CVSS changed

Sep 08, 2026 - 23:23 NVD

6.3 (MEDIUM)

Analysis Generated

Jul 09, 2026 - 22:11 vuln.today

DescriptionCVE.org

Impact

The GET /api/v2/shop/payment-requests/{hash} and PUT /api/v2/shop/payment-requests/{hash} endpoints look up the payment request solely by the hash from the URL. No ownership check is performed against the authenticated customer or the underlying order.

An attacker who obtains a payment request hash can:

read the payment request and, through the payment IRI in the response, recover the underlying order's tokenValue (which itself grants access to the full order, items, addresses, customer email, totals);
update the payment request payload (e.g. target_path, after_path). These fields are used by the front-end controller to redirect the user after the payment, so an attacker can flip them to an attacker-controlled URL and intercept the buyer.

The hash is a UUID, so it has to be obtained out-of-band (logs, shared links, referrer headers, a co-located client), but once it is known no other credential is required, neither authentication nor knowledge of the order token.

The creation endpoint POST /api/v2/shop/orders/{tokenValue}/payment-requests shares the same flaw: it resolves the target order solely from the tokenValue in the URL without verifying that the caller owns the order.

Patches

The issue is fixed in versions: 2.0.18, 2.1.15, 2.2.6.

Workarounds

Until you can upgrade, apply the following workaround. It enforces ownership on the existing endpoints, so that:

an authenticated shop user may only access payment requests of their own orders;
an anonymous caller may only access payment requests of guest orders (the order's customer has no associated user account);
everyone else receives 404 Not Found.

Step 1. Add a query extension that filters the `GET` operation

Create file src/ApiPlatform/QueryExtension/PaymentRequestOwnershipExtension.php:

php

<?php

declare(strict_types=1);

namespace App\ApiPlatform\QueryExtension;

use ApiPlatform\Doctrine\Orm\Extension\QueryItemExtensionInterface;
use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
use ApiPlatform\Metadata\Operation;
use Doctrine\ORM\QueryBuilder;
use Sylius\Bundle\ApiBundle\Context\UserContextInterface;
use Sylius\Bundle\ApiBundle\SectionResolver\ShopApiSection;
use Sylius\Bundle\CoreBundle\SectionResolver\SectionProviderInterface;
use Sylius\Component\Core\Model\ShopUserInterface;
use Sylius\Component\Payment\Model\PaymentRequestInterface;

final readonly class PaymentRequestOwnershipExtension implements QueryItemExtensionInterface
{
    public function __construct(
        private SectionProviderInterface $sectionProvider,
        private UserContextInterface $userContext,
    ) {
    }

    public function applyToItem(
        QueryBuilder $queryBuilder,
        QueryNameGeneratorInterface $queryNameGenerator,
        string $resourceClass,
        array $identifiers,
        ?Operation $operation = null,
        array $context = [],
    ): void {
        if (!is_a($resourceClass, PaymentRequestInterface::class, true)) {
            return;
        }

        if (!$this->sectionProvider->getSection() instanceof ShopApiSection) {
            return;
        }

        $rootAlias = $queryBuilder->getRootAliases()[0];
        $paymentJoin = $queryNameGenerator->generateJoinAlias('payment');
        $orderJoin = $queryNameGenerator->generateJoinAlias('order');
        $customerJoin = $queryNameGenerator->generateJoinAlias('customer');
        $userJoin = $queryNameGenerator->generateJoinAlias('user');
        $createdByGuestParameterName = $queryNameGenerator->generateParameterName('createdByGuest');

        $queryBuilder
            ->innerJoin(sprintf('%s.payment', $rootAlias), $paymentJoin)
            ->innerJoin(sprintf('%s.order', $paymentJoin), $orderJoin)
            ->leftJoin(sprintf('%s.customer', $orderJoin), $customerJoin)
            ->leftJoin(sprintf('%s.user', $customerJoin), $userJoin)
        ;

        $user = $this->userContext->getUser();

        if ($user instanceof ShopUserInterface) {
            $customerParam = $queryNameGenerator->generateParameterName('customer');

            $queryBuilder
                ->andWhere($queryBuilder->expr()->eq(sprintf('%s.customer', $orderJoin), sprintf(':%s', $customerParam)))
                ->setParameter($customerParam, $user->getCustomer())
            ;

            return;
        }

        $queryBuilder
            ->andWhere(
                $queryBuilder->expr()->orX(
                    $queryBuilder->expr()->isNull($userJoin),
                    $queryBuilder->expr()->isNull(sprintf('%s.customer', $orderJoin)),
                    $queryBuilder->expr()->andX(
                        $queryBuilder->expr()->isNotNull($userJoin),
                        $queryBuilder->expr()->eq(sprintf('%s.createdByGuest', $orderJoin), sprintf(':%s', $createdByGuestParameterName)),
                    ),
                ),
            )
            ->setParameter($createdByGuestParameterName, true)
        ;
    }
}

Step 2. Decorate the `PUT` state provider

Create file src/ApiPlatform/StateProvider/PaymentRequestOwnershipProvider.php:

php

<?php

declare(strict_types=1);

namespace App\ApiPlatform\StateProvider;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProviderInterface;
use Sylius\Bundle\ApiBundle\Context\UserContextInterface;
use Sylius\Component\Core\Model\CustomerInterface;
use Sylius\Component\Core\Model\OrderInterface;
use Sylius\Component\Core\Model\PaymentInterface;
use Sylius\Component\Core\Model\ShopUserInterface;
use Sylius\Component\Payment\Model\PaymentRequestInterface;

/** @implements ProviderInterface<PaymentRequestInterface> */
final readonly class PaymentRequestOwnershipProvider implements ProviderInterface
{
    /** @param ProviderInterface<PaymentRequestInterface> $inner */
    public function __construct(
        private ProviderInterface $inner,
        private UserContextInterface $userContext,
    ) {
    }

    public function provide(Operation $operation, array $uriVariables = [], array $context = []): array|object|null
    {
        $paymentRequest = $this->inner->provide($operation, $uriVariables, $context);
        if (!$paymentRequest instanceof PaymentRequestInterface) {
            return $paymentRequest;
        }

        if (!$this->isAccessible($paymentRequest)) {
            return null;
        }

        return $paymentRequest;
    }

    private function isAccessible(PaymentRequestInterface $paymentRequest): bool
    {
        $payment = $paymentRequest->getPayment();
        if (!$payment instanceof PaymentInterface) {
            return false;
        }

        $order = $payment->getOrder();
        if (!$order instanceof OrderInterface) {
            return false;
        }

        $user = $this->userContext->getUser();

        if ($user instanceof ShopUserInterface) {
            $customer = $user->getCustomer();

            return $customer instanceof CustomerInterface && $order->getCustomer() === $customer;
        }

        $customer = $order->getCustomer();

        return null === $customer
               || null === $customer->getUser()
               || $order->isCreatedByGuest();
    }
}

Step 3. Guard the `POST` creation endpoint with a command-bus middleware

The POST /api/v2/shop/orders/{tokenValue}/payment-requests operation is a messenger: input operation: it dispatches a Sylius\Bundle\ApiBundle\Command\Payment\AddPaymentRequest command whose orderTokenValue comes straight from the URL, so no query extension or state provider runs. Add a middleware on the Sylius command bus that loads the order, applies the same ownership rule, and aborts with 404 before the handler runs.

Create file src/Messenger/Middleware/PaymentRequestOwnershipMiddleware.php:

php

<?php

declare(strict_types=1);

namespace App\Messenger\Middleware;

use Sylius\Bundle\ApiBundle\Command\Payment\AddPaymentRequest;
use Sylius\Bundle\ApiBundle\Context\UserContextInterface;
use Sylius\Component\Core\Model\CustomerInterface;
use Sylius\Component\Core\Model\OrderInterface;
use Sylius\Component\Core\Model\ShopUserInterface;
use Sylius\Component\Core\Repository\OrderRepositoryInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
use Symfony\Component\Messenger\Middleware\StackInterface;

final readonly class PaymentRequestOwnershipMiddleware implements MiddlewareInterface
{
    /** @param OrderRepositoryInterface<OrderInterface> $orderRepository */
    public function __construct(
        private OrderRepositoryInterface $orderRepository,
        private UserContextInterface $userContext,
    ) {
    }

    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        $command = $envelope->getMessage();

        if ($command instanceof AddPaymentRequest && !$this->isOrderAccessible($command->orderTokenValue)) {
            throw new NotFoundHttpException('Not Found');
        }

        return $stack->next()->handle($envelope, $stack);
    }

    private function isOrderAccessible(string $orderTokenValue): bool
    {
        /** @var OrderInterface|null $order */
        $order = $this->orderRepository->findOneByTokenValue($orderTokenValue);
        if (null === $order) {
            // Unknown token - let the handler return its own 404 (PaymentNotFoundException).
            return true;
        }

        $user = $this->userContext->getUser();

        if ($user instanceof ShopUserInterface) {
            $customer = $user->getCustomer();

            return $customer instanceof CustomerInterface && $order->getCustomer() === $customer;
        }

        $customer = $order->getCustomer();

        return null === $customer
            || null === $customer->getUser()
            || $order->isCreatedByGuest();
    }
}

Step 4. Wire the services

Append to config/services.yaml:

yaml

services:
    App\ApiPlatform\QueryExtension\PaymentRequestOwnershipExtension:
        arguments:
            - '@sylius.section_resolver.uri_based'
            - '@sylius_api.context.user.token_based'
        tags:
            - { name: api_platform.doctrine.orm.query_extension.item }

    App\ApiPlatform\StateProvider\PaymentRequestOwnershipProvider:
        decorates: sylius_api.state_provider.shop.payment.payment_request.item
        arguments:
            $inner: '@.inner'
            $userContext: '@sylius_api.context.user.token_based'

    App\Messenger\Middleware\PaymentRequestOwnershipMiddleware:
        arguments:
            - '@sylius.repository.order'
            - '@sylius_api.context.user.token_based'

With the default Sylius-Standard services.yaml (autowire: true, autoconfigure: true) the two classes are already autoloaded, the block above only adds the tag and the decoration, which cannot be derived from the constructor signatures.

Step 5. Register the middleware on the Sylius command bus

Add to config/packages/messenger.yaml:

yaml

framework:
    messenger:
        buses:
            sylius.command_bus:
                middleware:
                    - 'App\Messenger\Middleware\PaymentRequestOwnershipMiddleware'
                    - 'validation'
                    - 'doctrine_transaction'

Step 6. Clear the cache

bash

bin/console cache:clear

Reporters

We would like to extend our gratitude to the following individuals for their detailed reporting and responsible disclosure of this vulnerability:

Fase Rais Baradika (@baradika)
Anshu Chimala (@achimala)

For more information

If you have any questions or comments about this advisory:

Open an issue in Sylius issues
Email us at [security@sylius.com](mailto:security@sylius.com)

AnalysisAI

Missing ownership enforcement on Sylius Shop API payment request endpoints allows any caller who possesses a valid payment request UUID hash to read sensitive order data - including customer email, shipping addresses, and order totals - or manipulate post-payment redirect URLs to an attacker-controlled domain. Affected versions span the 2.0.x, 2.1.x, and 2.2.x release lines, with fixes available in 2.0.18, 2.1.15, and 2.2.6 per the vendor advisory GHSA-mr9r-h354-966r. No public exploit code or CISA KEV listing has been identified at time of analysis; real-world exploitability is gated on acquiring the UUID hash out-of-band.

Technical ContextAI

Sylius (pkg:composer/sylius/sylius) is a PHP open-source e-commerce framework built on Symfony and API Platform. The vulnerable surface spans three Shop API endpoints: GET and PUT /api/v2/shop/payment-requests/{hash}, which resolve the payment request solely by the UUID hash in the URL, and POST /api/v2/shop/orders/{tokenValue}/payment-requests, which dispatches an AddPaymentRequest command to the Symfony Messenger command bus using only the tokenValue URL parameter. CWE-639 (Authorization Bypass Through User-Controlled Key) is the root cause: API Platform's query extensions and state providers do not apply ownership checks by default, and the Messenger middleware chain for the POST path similarly contains no authorization gate, so the UUID hash or order token alone is sufficient to access or modify any payment request regardless of the requester's identity.

RemediationAI

Upgrade to Sylius 2.0.18, 2.1.15, or 2.2.6 as appropriate for the installed release branch; these versions introduce ownership enforcement directly into the affected endpoints. Until upgrade is feasible, the vendor advisory at https://github.com/Sylius/Sylius/security/advisories/GHSA-mr9r-h354-966r provides a six-step workaround: (1) add a Doctrine ORM query extension (PaymentRequestOwnershipExtension) to filter GET lookups by the authenticated customer or guest status; (2) decorate the API Platform state provider for PUT operations (PaymentRequestOwnershipProvider) to enforce the same ownership rule; (3) add a Symfony Messenger middleware (PaymentRequestOwnershipMiddleware) on the sylius.command_bus to guard the POST command-bus path before the handler runs; (4) wire all three services in config/services.yaml with the required tags and decoration; (5) register the middleware on the sylius.command_bus in config/packages/messenger.yaml ahead of the validation and doctrine_transaction middleware; and (6) clear the Symfony cache with bin/console cache:clear. As a supplementary compensating control, enforce a strict Referrer-Policy HTTP header (e.g., no-referrer or same-origin) and restrict access to application logs to reduce UUID leakage; note these controls limit the out-of-band hash acquisition path but do not fix the authorization flaw.