ncryptf\middleware\RequestParser

Complexity

Total Complexity

17

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	decryptRequest()	0	31	5
A	__construct()	0	3	1
A	process()	0	25	5
A	checkRequest()	0	9	3
A	getEncryptionKey()	0	12	3

<?php declare(strict_types=1);

namespace ncryptf\middleware;

use Exception;

use ncryptf\Response;

use Psr\SimpleCache\CacheInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\ResponseInterface;

use Psr\Http\Server\MiddlewareInterface;
use Fig\Http\Message\StatusCodeInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\SimpleCache\InvalidArgumentException;

use ncryptf\middleware\EncryptionKeyInterface;

final class RequestParser implements MiddlewareInterface
{
    /**
     * @var array $contentType
     */
    protected $contentType = [
        'application/vnd.25519+json',
        'application/vnd.ncryptf+json'
    ];

    /**
     * Constructor
     * @param CacheInterface $cache     A PSR-16 CacheInterface
     */
    public function __construct(CacheInterface $cache)
    {
        $this->cache = $cache;

The property cache does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * Processes the request
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $handler
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        if ($this->checkRequest($request)) {
            try {
                $rawBody = \base64_decode($request->getBody()->getContents());
                if ($rawBody === '') {
                    $request = $request->withParsedBody([]);
                    $request->withAttribute('ncryptf-decrypted-body', '');
                } else {
                    $version = Response::getVersion($rawBody);
                    $key = $this->getEncryptionKey($request);

                    $body = $this->decryptRequest($key, $request, $rawBody, $version);
                    $request = $request->withParsedBody(\json_decode($body, true, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION))
                        ->withAttribute('ncryptf-decrypted-body', $body)
                        ->withAttribute('ncryptf-version', $version)
                        ->withAttribute('ncryptf-request-public-key', $version === 2 ? Response::getPublicKeyFromResponse($rawBody) : $request->getHeaderLine('x-pubkey'));
                }
            } catch (DecryptionFailedException | InvalidArgumentException | InvalidSignatureException | InvalidChecksumException | Exception $e) {

The type ncryptf\middleware\InvalidChecksumException was not found. Maybe you did not declare it correctly or list all dependencies?

The type ncryptf\middleware\DecryptionFailedException was not found. Maybe you did not declare it correctly or list all dependencies?

The type ncryptf\middleware\InvalidSignatureException was not found. Maybe you did not declare it correctly or list all dependencies?

                return $handler->handle($request)
                        ->withStatus(401);
            }
        }

        return $handler->handle($request);
    }

    /**
     * Decrypts a request
     * @param EncryptionKeyInterface $key
     * @param ServerRequestInterface $request
     * @param string $rawBody
     * @param int $version
     * @return string|null
     */
    private function decryptRequest(EncryptionKeyInterface $key, ServerRequestInterface $request, string $rawBody, int $version) :? string
    {
        static $response = null;
        static $nonce = null;
        static $publicKey = null;

        $response = new Response(
            $key->getBoxSecretKey()
        );

        if ($version === 1) {
            if (!$request->hasHeader('x-pubkey') || !$request->hasHeader('x-nonce')) {
                throw new Exception('Missing nonce or public key header. Unable to decrypt response.');
            }

            $publicKey = \base64_decode($request->getHeaderLine('x-pubkey'));
            $nonce = \base64_decode($request->getHeaderLine('x-nonce'));
        }

        $decryptedRequest = $response->decrypt(
            $rawBody,
            $publicKey,
            $nonce
        );

        $hashKey = $request->getHeaderLine('x-hashid');
        if ($key->isEphemeral()) {
            $this->cache->delete($hashKey);
        }

        return $decryptedRequest;
    }

    /**
     * Determines the key from the X-HashId header
     * @param ServerRequestInterface
     * @return EncryptionKeyInterface
     */
    private function getEncryptionKey(ServerRequestInterface $request) : EncryptionKeyInterface
    {
        if (!$request->hasHeader('x-hashid')) {
            throw new Exception('Unable to decrypt request.');
        }

        $hashKey = $request->getHeaderLine('x-hashid');

        try {
            return $this->cache->get($hashKey);
        } catch (InvalidArgumentException $e) {
            throw new Exception('Unable to decrypt request.', null, $e);
        }
    }

    /**
     * Check whether the request payload need to be processed
     */
    private function checkRequest(ServerRequestInterface $request): bool
    {
        $contentType = $request->getHeaderLine('Content-Type');
        foreach ($this->contentType as $allowedType) {
            if (stripos($contentType, $allowedType) === 0) {
                return true;
            }
        }
        return false;
    }
}